﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using HslCommunication.BasicFramework;
using HslCommunication.Core;
using HslCommunication.Core.Net;
using HslCommunication.Reflection;

namespace HslCommunication.Enthernet.Redis
{
	/// <summary>
	/// 这是一个redis的客户端类，支持读取，写入，发布订阅，但是不支持订阅，如果需要订阅，请使用另一个类<see cref="T:HslCommunication.Enthernet.Redis.RedisSubscribe" />
	/// </summary>
	/// <remarks>
	/// 本类库的API指令的参考及注释来源：http://doc.redisfans.com/index.html
	/// </remarks>
	/// <example>
	/// 基本的操作如下所示，举例了几个比较常见的指令，更多的需要参考api接口描述
	/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="SampleBasic" title="基本操作代码" />
	/// 如下是基于特性的操作，有必要说明以下：
	/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="Sample1" title="基础的使用" />
	/// 总的来说，当读取的数据种类比较多的时候，读取的关键字比较多的时候，处理起来就比较的麻烦，此处推荐一个全新的写法，为了更好的对比，我们假设实现一种需求
	/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="Sample2" title="同等代码" />
	/// 为此我们只需要实现一个特性类即可。代码如下：(注意，实际是很灵活的，类型都是自动转换的)
	/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="SampleClass" title="数据类" />
	/// </example>
	// Token: 0x02000107 RID: 263
	public class RedisClient : NetworkDoubleBase
	{
		/// <summary>
		/// 实例化一个客户端的对象，用于和服务器通信
		/// </summary>
		/// <param name="ipAddress">服务器的ip地址</param>
		/// <param name="port">服务器的端口号</param>
		/// <param name="password">密码，如果服务器没有设置，密码设置为null</param>
		// Token: 0x0600168A RID: 5770 RVA: 0x000740FC File Offset: 0x000722FC
		public RedisClient(string ipAddress, int port, string password)
		{
			base.ByteTransform = new RegularByteTransform();
			this.IpAddress = ipAddress;
			this.Port = port;
			base.ReceiveTimeOut = 30000;
			this.password = password;
			this.redisSubscribe = new Lazy<RedisSubscribe>(() => this.RedisSubscribeInitialize());
		}

		/// <summary>
		/// 实例化一个客户端对象，需要手动指定Ip地址和端口
		/// </summary>
		/// <param name="password">密码，如果服务器没有设置，密码设置为null</param>
		// Token: 0x0600168B RID: 5771 RVA: 0x0007416C File Offset: 0x0007236C
		public RedisClient(string password)
		{
			base.ByteTransform = new RegularByteTransform();
			base.ReceiveTimeOut = 30000;
			this.password = password;
			this.redisSubscribe = new Lazy<RedisSubscribe>(() => this.RedisSubscribeInitialize());
		}

		/// <inheritdoc />
		// Token: 0x0600168C RID: 5772 RVA: 0x000741CC File Offset: 0x000723CC
		protected override OperateResult InitializationOnConnect(Socket socket)
		{
			bool flag = !string.IsNullOrEmpty(this.password);
			if (flag)
			{
				byte[] send = RedisHelper.PackStringCommand(new string[]
				{
					"AUTH",
					this.password
				});
				OperateResult<byte[]> operateResult = this.ReadFromCoreServer(socket, send, true, true);
				bool flag2 = !operateResult.IsSuccess;
				if (flag2)
				{
					return OperateResult.CreateFailedResult<string>(operateResult);
				}
				string @string = Encoding.UTF8.GetString(operateResult.Content);
				bool flag3 = !@string.StartsWith("+");
				if (flag3)
				{
					return new OperateResult<string>(@string);
				}
			}
			bool flag4 = this.dbBlock > 0;
			if (flag4)
			{
				byte[] send2 = RedisHelper.PackStringCommand(new string[]
				{
					"SELECT",
					this.dbBlock.ToString()
				});
				OperateResult<byte[]> operateResult2 = this.ReadFromCoreServer(socket, send2, true, true);
				bool flag5 = !operateResult2.IsSuccess;
				if (flag5)
				{
					return OperateResult.CreateFailedResult<string>(operateResult2);
				}
				string string2 = Encoding.UTF8.GetString(operateResult2.Content);
				bool flag6 = !string2.StartsWith("+");
				if (flag6)
				{
					return new OperateResult<string>(string2);
				}
			}
			return base.InitializationOnConnect(socket);
		}

		/// <inheritdoc />
		// Token: 0x0600168D RID: 5773 RVA: 0x00074304 File Offset: 0x00072504
		public override OperateResult<byte[]> ReadFromCoreServer(Socket socket, byte[] send, bool hasResponseData = true, bool usePackHeader = true)
		{
			OperateResult operateResult = base.Send(socket, send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<byte[]> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<byte[]>(operateResult);
			}
			else
			{
				bool flag2 = base.ReceiveTimeOut < 0;
				if (flag2)
				{
					result = OperateResult.CreateSuccessResult<byte[]>(new byte[0]);
				}
				else
				{
					result = base.ReceiveRedisCommand(socket);
				}
			}
			return result;
		}

		/// <inheritdoc />
		// Token: 0x0600168E RID: 5774 RVA: 0x00074358 File Offset: 0x00072558
		[DebuggerStepThrough]
		protected override Task<OperateResult> InitializationOnConnectAsync(Socket socket)
		{
			RedisClient.<InitializationOnConnectAsync>d__4 <InitializationOnConnectAsync>d__ = new RedisClient.<InitializationOnConnectAsync>d__4();
			<InitializationOnConnectAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<InitializationOnConnectAsync>d__.<>4__this = this;
			<InitializationOnConnectAsync>d__.socket = socket;
			<InitializationOnConnectAsync>d__.<>1__state = -1;
			<InitializationOnConnectAsync>d__.<>t__builder.Start<RedisClient.<InitializationOnConnectAsync>d__4>(ref <InitializationOnConnectAsync>d__);
			return <InitializationOnConnectAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc />
		// Token: 0x0600168F RID: 5775 RVA: 0x000743A4 File Offset: 0x000725A4
		[DebuggerStepThrough]
		public override Task<OperateResult<byte[]>> ReadFromCoreServerAsync(Socket socket, byte[] send, bool hasResponseData = true, bool usePackHeader = true)
		{
			RedisClient.<ReadFromCoreServerAsync>d__5 <ReadFromCoreServerAsync>d__ = new RedisClient.<ReadFromCoreServerAsync>d__5();
			<ReadFromCoreServerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<byte[]>>.Create();
			<ReadFromCoreServerAsync>d__.<>4__this = this;
			<ReadFromCoreServerAsync>d__.socket = socket;
			<ReadFromCoreServerAsync>d__.send = send;
			<ReadFromCoreServerAsync>d__.hasResponseData = hasResponseData;
			<ReadFromCoreServerAsync>d__.usePackHeader = usePackHeader;
			<ReadFromCoreServerAsync>d__.<>1__state = -1;
			<ReadFromCoreServerAsync>d__.<>t__builder.Start<RedisClient.<ReadFromCoreServerAsync>d__5>(ref <ReadFromCoreServerAsync>d__);
			return <ReadFromCoreServerAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 自定义的指令交互方法，该指令用空格分割，举例：LTRIM AAAAA 0 999 就是收缩列表，GET AAA 就是获取键值，需要对返回的数据进行二次分析
		/// </summary>
		/// <param name="command">举例：LTRIM AAAAA 0 999 就是收缩列表，GET AAA 就是获取键值</param>
		/// <returns>从服务器返回的结果数据对象</returns>
		// Token: 0x06001690 RID: 5776 RVA: 0x00074408 File Offset: 0x00072608
		public OperateResult<string> ReadCustomer(string command)
		{
			byte[] send = RedisHelper.PackStringCommand(command.Split(new char[]
			{
				' '
			}));
			OperateResult<byte[]> operateResult = base.ReadFromCoreServer(send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<string> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<string>(operateResult);
			}
			else
			{
				result = OperateResult.CreateSuccessResult<string>(Encoding.UTF8.GetString(operateResult.Content));
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadCustomer(System.String)" />
		// Token: 0x06001691 RID: 5777 RVA: 0x00074464 File Offset: 0x00072664
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadCustomerAsync(string command)
		{
			RedisClient.<ReadCustomerAsync>d__7 <ReadCustomerAsync>d__ = new RedisClient.<ReadCustomerAsync>d__7();
			<ReadCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadCustomerAsync>d__.<>4__this = this;
			<ReadCustomerAsync>d__.command = command;
			<ReadCustomerAsync>d__.<>1__state = -1;
			<ReadCustomerAsync>d__.<>t__builder.Start<RedisClient.<ReadCustomerAsync>d__7>(ref <ReadCustomerAsync>d__);
			return <ReadCustomerAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 向服务器请求指定，并返回数字的结果对象
		/// </summary>
		/// <param name="commands">命令数组</param>
		/// <returns>数字的结果对象</returns>
		// Token: 0x06001692 RID: 5778 RVA: 0x000744B0 File Offset: 0x000726B0
		public OperateResult<int> OperateNumberFromServer(string[] commands)
		{
			byte[] send = RedisHelper.PackStringCommand(commands);
			OperateResult<byte[]> operateResult = base.ReadFromCoreServer(send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<int> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<int>(operateResult);
			}
			else
			{
				string @string = Encoding.UTF8.GetString(operateResult.Content);
				bool flag2 = !@string.StartsWith(":");
				if (flag2)
				{
					result = new OperateResult<int>(@string);
				}
				else
				{
					result = RedisHelper.GetNumberFromCommandLine(operateResult.Content);
				}
			}
			return result;
		}

		/// <summary>
		/// 向服务器请求指令，并返回long数字的结果对象
		/// </summary>
		/// <param name="commands">命令数组</param>
		/// <returns>long数字的结果对象</returns>
		// Token: 0x06001693 RID: 5779 RVA: 0x00074524 File Offset: 0x00072724
		public OperateResult<long> OperateLongNumberFromServer(string[] commands)
		{
			byte[] send = RedisHelper.PackStringCommand(commands);
			OperateResult<byte[]> operateResult = base.ReadFromCoreServer(send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<long> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<long>(operateResult);
			}
			else
			{
				string @string = Encoding.UTF8.GetString(operateResult.Content);
				bool flag2 = !@string.StartsWith(":");
				if (flag2)
				{
					result = new OperateResult<long>(@string);
				}
				else
				{
					result = RedisHelper.GetLongNumberFromCommandLine(operateResult.Content);
				}
			}
			return result;
		}

		/// <summary>
		/// 向服务器请求指令，并返回字符串的结果对象
		/// </summary>
		/// <param name="commands">命令数组</param>
		/// <returns>字符串的结果对象</returns>
		// Token: 0x06001694 RID: 5780 RVA: 0x00074598 File Offset: 0x00072798
		public OperateResult<string> OperateStringFromServer(string[] commands)
		{
			byte[] send = RedisHelper.PackStringCommand(commands);
			OperateResult<byte[]> operateResult = base.ReadFromCoreServer(send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<string> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<string>(operateResult);
			}
			else
			{
				result = RedisHelper.GetStringFromCommandLine(operateResult.Content);
			}
			return result;
		}

		/// <summary>
		/// 向服务器请求指令，并返回字符串数组的结果对象
		/// </summary>
		/// <param name="commands">命令数组</param>
		/// <returns>字符串数组的结果对象</returns>
		// Token: 0x06001695 RID: 5781 RVA: 0x000745DC File Offset: 0x000727DC
		public OperateResult<string[]> OperateStringsFromServer(string[] commands)
		{
			byte[] send = RedisHelper.PackStringCommand(commands);
			OperateResult<byte[]> operateResult = base.ReadFromCoreServer(send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<string[]> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<string[]>(operateResult);
			}
			else
			{
				result = RedisHelper.GetStringsFromCommandLine(operateResult.Content);
			}
			return result;
		}

		/// <summary>
		/// 向服务器请求指令，并返回状态的结果对象，通常用于写入的判断，或是请求类型的判断
		/// </summary>
		/// <param name="commands">命令数组</param>
		/// <returns>是否成功的结果对象</returns>
		// Token: 0x06001696 RID: 5782 RVA: 0x00074620 File Offset: 0x00072820
		public OperateResult<string> OperateStatusFromServer(string[] commands)
		{
			byte[] send = RedisHelper.PackStringCommand(commands);
			OperateResult<byte[]> operateResult = base.ReadFromCoreServer(send);
			bool flag = !operateResult.IsSuccess;
			OperateResult<string> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<string>(operateResult);
			}
			else
			{
				string @string = Encoding.UTF8.GetString(operateResult.Content);
				bool flag2 = !@string.StartsWith("+");
				if (flag2)
				{
					result = new OperateResult<string>(@string);
				}
				else
				{
					result = OperateResult.CreateSuccessResult<string>(@string.Substring(1).TrimEnd(new char[]
					{
						'\r',
						'\n'
					}));
				}
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.OperateNumberFromServer(System.String[])" />
		// Token: 0x06001697 RID: 5783 RVA: 0x000746AC File Offset: 0x000728AC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> OperateNumberFromServerAsync(string[] commands)
		{
			RedisClient.<OperateNumberFromServerAsync>d__13 <OperateNumberFromServerAsync>d__ = new RedisClient.<OperateNumberFromServerAsync>d__13();
			<OperateNumberFromServerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<OperateNumberFromServerAsync>d__.<>4__this = this;
			<OperateNumberFromServerAsync>d__.commands = commands;
			<OperateNumberFromServerAsync>d__.<>1__state = -1;
			<OperateNumberFromServerAsync>d__.<>t__builder.Start<RedisClient.<OperateNumberFromServerAsync>d__13>(ref <OperateNumberFromServerAsync>d__);
			return <OperateNumberFromServerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.OperateLongNumberFromServer(System.String[])" />
		// Token: 0x06001698 RID: 5784 RVA: 0x000746F8 File Offset: 0x000728F8
		[DebuggerStepThrough]
		public Task<OperateResult<long>> OperateLongNumberFromServerAsync(string[] commands)
		{
			RedisClient.<OperateLongNumberFromServerAsync>d__14 <OperateLongNumberFromServerAsync>d__ = new RedisClient.<OperateLongNumberFromServerAsync>d__14();
			<OperateLongNumberFromServerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<OperateLongNumberFromServerAsync>d__.<>4__this = this;
			<OperateLongNumberFromServerAsync>d__.commands = commands;
			<OperateLongNumberFromServerAsync>d__.<>1__state = -1;
			<OperateLongNumberFromServerAsync>d__.<>t__builder.Start<RedisClient.<OperateLongNumberFromServerAsync>d__14>(ref <OperateLongNumberFromServerAsync>d__);
			return <OperateLongNumberFromServerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.OperateStringFromServer(System.String[])" />
		// Token: 0x06001699 RID: 5785 RVA: 0x00074744 File Offset: 0x00072944
		[DebuggerStepThrough]
		public Task<OperateResult<string>> OperateStringFromServerAsync(string[] commands)
		{
			RedisClient.<OperateStringFromServerAsync>d__15 <OperateStringFromServerAsync>d__ = new RedisClient.<OperateStringFromServerAsync>d__15();
			<OperateStringFromServerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<OperateStringFromServerAsync>d__.<>4__this = this;
			<OperateStringFromServerAsync>d__.commands = commands;
			<OperateStringFromServerAsync>d__.<>1__state = -1;
			<OperateStringFromServerAsync>d__.<>t__builder.Start<RedisClient.<OperateStringFromServerAsync>d__15>(ref <OperateStringFromServerAsync>d__);
			return <OperateStringFromServerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.OperateStringsFromServer(System.String[])" />
		// Token: 0x0600169A RID: 5786 RVA: 0x00074790 File Offset: 0x00072990
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> OperateStringsFromServerAsync(string[] commands)
		{
			RedisClient.<OperateStringsFromServerAsync>d__16 <OperateStringsFromServerAsync>d__ = new RedisClient.<OperateStringsFromServerAsync>d__16();
			<OperateStringsFromServerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<OperateStringsFromServerAsync>d__.<>4__this = this;
			<OperateStringsFromServerAsync>d__.commands = commands;
			<OperateStringsFromServerAsync>d__.<>1__state = -1;
			<OperateStringsFromServerAsync>d__.<>t__builder.Start<RedisClient.<OperateStringsFromServerAsync>d__16>(ref <OperateStringsFromServerAsync>d__);
			return <OperateStringsFromServerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.OperateStatusFromServer(System.String[])" />
		// Token: 0x0600169B RID: 5787 RVA: 0x000747DC File Offset: 0x000729DC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> OperateStatusFromServerAsync(string[] commands)
		{
			RedisClient.<OperateStatusFromServerAsync>d__17 <OperateStatusFromServerAsync>d__ = new RedisClient.<OperateStatusFromServerAsync>d__17();
			<OperateStatusFromServerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<OperateStatusFromServerAsync>d__.<>4__this = this;
			<OperateStatusFromServerAsync>d__.commands = commands;
			<OperateStatusFromServerAsync>d__.<>1__state = -1;
			<OperateStatusFromServerAsync>d__.<>t__builder.Start<RedisClient.<OperateStatusFromServerAsync>d__17>(ref <OperateStatusFromServerAsync>d__);
			return <OperateStatusFromServerAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 删除给定的一个或多个 key 。不存在的 key 会被忽略。
		/// </summary>
		/// <param name="keys">关键字</param>
		/// <returns>被删除 key 的数量。</returns>
		// Token: 0x0600169C RID: 5788 RVA: 0x00074827 File Offset: 0x00072A27
		public OperateResult<int> DeleteKey(string[] keys)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("DEL", keys));
		}

		/// <summary>
		/// 删除给定的一个或多个 key 。不存在的 key 会被忽略。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>被删除 key 的数量。</returns>
		// Token: 0x0600169D RID: 5789 RVA: 0x0007483A File Offset: 0x00072A3A
		public OperateResult<int> DeleteKey(string key)
		{
			return this.DeleteKey(new string[]
			{
				key
			});
		}

		/// <summary>
		/// 检查给定 key 是否存在。若 key 存在，返回 1 ，否则返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>若 key 存在，返回 1 ，否则返回 0 。</returns>
		// Token: 0x0600169E RID: 5790 RVA: 0x0007484C File Offset: 0x00072A4C
		public OperateResult<int> ExistsKey(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"EXISTS",
				key
			});
		}

		/// <summary>
		/// 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。设置成功返回 1 。当 key 不存在或者不能为 key 设置生存时间时，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="seconds">当前key的生存时间，单位为秒</param>
		/// <returns>
		/// 设置成功返回 1 。当 key 不存在或者不能为 key 设置生存时间时，返回 0 。
		/// </returns>
		/// <remarks>
		/// 在 Redis 中，带有生存时间的 key 被称为『易失的』(volatile)。<br />
		/// 生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写( overwrite)，这意味着，如果一个命令只是修改( alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替( replace)它的话，那么生存时间不会被改变。<br />
		/// 比如说，对一个 key 执行 INCR 命令，对一个列表进行 LPUSH 命令，或者对一个哈希表执行 HSET 命令，这类操作都不会修改 key 本身的生存时间。<br />
		/// 另一方面，如果使用 RENAME 对一个 key 进行改名，那么改名后的 key 的生存时间和改名前一样。<br />
		/// RENAME 命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key( 以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。<br />
		/// 使用 PERSIST 命令可以在不删除 key 的情况下，移除 key 的生存时间，让 key 重新成为一个『持久的』(persistent) key 。<br />
		/// 更新生存时间<br />
		/// 可以对一个已经带有生存时间的 key 执行 EXPIRE 命令，新指定的生存时间会取代旧的生存时间。<br />
		/// 过期时间的精确度<br />
		/// 在 Redis 2.4 版本中，过期时间的延迟在 1 秒钟之内 —— 也即是，就算 key 已经过期，但它还是可能在过期之后一秒钟之内被访问到，而在新的 Redis 2.6 版本中，延迟被降低到 1 毫秒之内。<br />
		/// Redis 2.1.3 之前的不同之处<br />
		/// 在 Redis 2.1.3 之前的版本中，修改一个带有生存时间的 key 会导致整个 key 被删除，这一行为是受当时复制( replication)层的限制而作出的，现在这一限制已经被修复。<br />
		/// </remarks>
		// Token: 0x0600169F RID: 5791 RVA: 0x00074866 File Offset: 0x00072A66
		public OperateResult<int> ExpireKey(string key, int seconds)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"EXPIRE",
				key,
				seconds.ToString()
			});
		}

		/// <summary>
		/// 查找所有符合给定模式 pattern 的 key 。
		/// * 匹配数据库中所有 key。
		/// h?llo 匹配 hello ， hallo 和 hxllo 等。
		/// h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
		/// </summary>
		/// <param name="pattern">给定模式</param>
		/// <returns>符合给定模式的 key 列表。</returns>
		// Token: 0x060016A0 RID: 5792 RVA: 0x0007488A File Offset: 0x00072A8A
		public OperateResult<string[]> ReadAllKeys(string pattern)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"KEYS",
				pattern
			});
		}

		/// <summary>
		/// 将当前数据库的 key 移动到给定的数据库 db 当中。
		/// 如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
		/// 因此，也可以利用这一特性，将 MOVE 当作锁(locking)原语(primitive)。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="db">数据块</param>
		/// <returns>是否移动成功</returns>
		// Token: 0x060016A1 RID: 5793 RVA: 0x000748A4 File Offset: 0x00072AA4
		public OperateResult MoveKey(string key, int db)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"MOVE",
				key,
				db.ToString()
			});
		}

		/// <summary>
		/// 移除给定 key 的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
		/// 当生存时间移除成功时，返回 1 .
		/// 如果 key 不存在或 key 没有设置生存时间，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>
		/// 当生存时间移除成功时，返回 1 .
		/// 如果 key 不存在或 key 没有设置生存时间，返回 0 。
		/// </returns>
		// Token: 0x060016A2 RID: 5794 RVA: 0x000748C8 File Offset: 0x00072AC8
		public OperateResult<int> PersistKey(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"PERSIST",
				key
			});
		}

		/// <summary>
		/// 从当前数据库中随机返回(不删除)一个 key 。
		/// 当数据库不为空时，返回一个 key 。
		/// 当数据库为空时，返回 nil 。
		/// </summary>
		/// <returns>
		/// 当数据库不为空时，返回一个 key 。
		/// 当数据库为空时，返回 nil 。
		/// </returns>
		// Token: 0x060016A3 RID: 5795 RVA: 0x000748E2 File Offset: 0x00072AE2
		public OperateResult<string> ReadRandomKey()
		{
			return this.OperateStringFromServer(new string[]
			{
				"RANDOMKEY"
			});
		}

		/// <summary>
		/// 将 key 改名为 newkey 。
		/// 当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。
		/// 当 newkey 已经存在时， RENAME 命令将覆盖旧值。
		/// </summary>
		/// <param name="key1">旧的key</param>
		/// <param name="key2">新的key</param>
		/// <returns>
		/// 改名成功时提示 OK ，失败时候返回一个错误。
		/// </returns>
		// Token: 0x060016A4 RID: 5796 RVA: 0x000748F8 File Offset: 0x00072AF8
		public OperateResult RenameKey(string key1, string key2)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"RENAME",
				key1,
				key2
			});
		}

		/// <summary>
		/// 返回 key 所储存的值的类型。none (key不存在)，string (字符串)，list (列表)，set (集合)，zset (有序集)，hash (哈希表)
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>类型</returns>
		// Token: 0x060016A5 RID: 5797 RVA: 0x00074916 File Offset: 0x00072B16
		public OperateResult<string> ReadKeyType(string key)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"TYPE",
				key
			});
		}

		/// <summary>
		/// 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。否则，以秒为单位，返回 key 的剩余生存时间。</returns>
		// Token: 0x060016A6 RID: 5798 RVA: 0x00074930 File Offset: 0x00072B30
		public OperateResult<int> ReadKeyTTL(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"TTL",
				key
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteKey(System.String[])" />
		// Token: 0x060016A7 RID: 5799 RVA: 0x0007494C File Offset: 0x00072B4C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteKeyAsync(string[] keys)
		{
			RedisClient.<DeleteKeyAsync>d__29 <DeleteKeyAsync>d__ = new RedisClient.<DeleteKeyAsync>d__29();
			<DeleteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteKeyAsync>d__.<>4__this = this;
			<DeleteKeyAsync>d__.keys = keys;
			<DeleteKeyAsync>d__.<>1__state = -1;
			<DeleteKeyAsync>d__.<>t__builder.Start<RedisClient.<DeleteKeyAsync>d__29>(ref <DeleteKeyAsync>d__);
			return <DeleteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteKey(System.String)" />
		// Token: 0x060016A8 RID: 5800 RVA: 0x00074998 File Offset: 0x00072B98
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteKeyAsync(string key)
		{
			RedisClient.<DeleteKeyAsync>d__30 <DeleteKeyAsync>d__ = new RedisClient.<DeleteKeyAsync>d__30();
			<DeleteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteKeyAsync>d__.<>4__this = this;
			<DeleteKeyAsync>d__.key = key;
			<DeleteKeyAsync>d__.<>1__state = -1;
			<DeleteKeyAsync>d__.<>t__builder.Start<RedisClient.<DeleteKeyAsync>d__30>(ref <DeleteKeyAsync>d__);
			return <DeleteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ExistsKey(System.String)" />
		// Token: 0x060016A9 RID: 5801 RVA: 0x000749E4 File Offset: 0x00072BE4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ExistsKeyAsync(string key)
		{
			RedisClient.<ExistsKeyAsync>d__31 <ExistsKeyAsync>d__ = new RedisClient.<ExistsKeyAsync>d__31();
			<ExistsKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ExistsKeyAsync>d__.<>4__this = this;
			<ExistsKeyAsync>d__.key = key;
			<ExistsKeyAsync>d__.<>1__state = -1;
			<ExistsKeyAsync>d__.<>t__builder.Start<RedisClient.<ExistsKeyAsync>d__31>(ref <ExistsKeyAsync>d__);
			return <ExistsKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ExpireKey(System.String,System.Int32)" />
		// Token: 0x060016AA RID: 5802 RVA: 0x00074A30 File Offset: 0x00072C30
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ExpireKeyAsync(string key, int seconds)
		{
			RedisClient.<ExpireKeyAsync>d__32 <ExpireKeyAsync>d__ = new RedisClient.<ExpireKeyAsync>d__32();
			<ExpireKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ExpireKeyAsync>d__.<>4__this = this;
			<ExpireKeyAsync>d__.key = key;
			<ExpireKeyAsync>d__.seconds = seconds;
			<ExpireKeyAsync>d__.<>1__state = -1;
			<ExpireKeyAsync>d__.<>t__builder.Start<RedisClient.<ExpireKeyAsync>d__32>(ref <ExpireKeyAsync>d__);
			return <ExpireKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadAllKeys(System.String)" />
		// Token: 0x060016AB RID: 5803 RVA: 0x00074A84 File Offset: 0x00072C84
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadAllKeysAsync(string pattern)
		{
			RedisClient.<ReadAllKeysAsync>d__33 <ReadAllKeysAsync>d__ = new RedisClient.<ReadAllKeysAsync>d__33();
			<ReadAllKeysAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadAllKeysAsync>d__.<>4__this = this;
			<ReadAllKeysAsync>d__.pattern = pattern;
			<ReadAllKeysAsync>d__.<>1__state = -1;
			<ReadAllKeysAsync>d__.<>t__builder.Start<RedisClient.<ReadAllKeysAsync>d__33>(ref <ReadAllKeysAsync>d__);
			return <ReadAllKeysAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.MoveKey(System.String,System.Int32)" />
		// Token: 0x060016AC RID: 5804 RVA: 0x00074AD0 File Offset: 0x00072CD0
		[DebuggerStepThrough]
		public Task<OperateResult> MoveKeyAsync(string key, int db)
		{
			RedisClient.<MoveKeyAsync>d__34 <MoveKeyAsync>d__ = new RedisClient.<MoveKeyAsync>d__34();
			<MoveKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<MoveKeyAsync>d__.<>4__this = this;
			<MoveKeyAsync>d__.key = key;
			<MoveKeyAsync>d__.db = db;
			<MoveKeyAsync>d__.<>1__state = -1;
			<MoveKeyAsync>d__.<>t__builder.Start<RedisClient.<MoveKeyAsync>d__34>(ref <MoveKeyAsync>d__);
			return <MoveKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.PersistKey(System.String)" />
		// Token: 0x060016AD RID: 5805 RVA: 0x00074B24 File Offset: 0x00072D24
		[DebuggerStepThrough]
		public Task<OperateResult<int>> PersistKeyAsync(string key)
		{
			RedisClient.<PersistKeyAsync>d__35 <PersistKeyAsync>d__ = new RedisClient.<PersistKeyAsync>d__35();
			<PersistKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<PersistKeyAsync>d__.<>4__this = this;
			<PersistKeyAsync>d__.key = key;
			<PersistKeyAsync>d__.<>1__state = -1;
			<PersistKeyAsync>d__.<>t__builder.Start<RedisClient.<PersistKeyAsync>d__35>(ref <PersistKeyAsync>d__);
			return <PersistKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadRandomKey" />
		// Token: 0x060016AE RID: 5806 RVA: 0x00074B70 File Offset: 0x00072D70
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadRandomKeyAsync()
		{
			RedisClient.<ReadRandomKeyAsync>d__36 <ReadRandomKeyAsync>d__ = new RedisClient.<ReadRandomKeyAsync>d__36();
			<ReadRandomKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadRandomKeyAsync>d__.<>4__this = this;
			<ReadRandomKeyAsync>d__.<>1__state = -1;
			<ReadRandomKeyAsync>d__.<>t__builder.Start<RedisClient.<ReadRandomKeyAsync>d__36>(ref <ReadRandomKeyAsync>d__);
			return <ReadRandomKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.RenameKey(System.String,System.String)" />
		// Token: 0x060016AF RID: 5807 RVA: 0x00074BB4 File Offset: 0x00072DB4
		[DebuggerStepThrough]
		public Task<OperateResult> RenameKeyAsync(string key1, string key2)
		{
			RedisClient.<RenameKeyAsync>d__37 <RenameKeyAsync>d__ = new RedisClient.<RenameKeyAsync>d__37();
			<RenameKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<RenameKeyAsync>d__.<>4__this = this;
			<RenameKeyAsync>d__.key1 = key1;
			<RenameKeyAsync>d__.key2 = key2;
			<RenameKeyAsync>d__.<>1__state = -1;
			<RenameKeyAsync>d__.<>t__builder.Start<RedisClient.<RenameKeyAsync>d__37>(ref <RenameKeyAsync>d__);
			return <RenameKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyType(System.String)" />
		// Token: 0x060016B0 RID: 5808 RVA: 0x00074C08 File Offset: 0x00072E08
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadKeyTypeAsync(string key)
		{
			RedisClient.<ReadKeyTypeAsync>d__38 <ReadKeyTypeAsync>d__ = new RedisClient.<ReadKeyTypeAsync>d__38();
			<ReadKeyTypeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadKeyTypeAsync>d__.<>4__this = this;
			<ReadKeyTypeAsync>d__.key = key;
			<ReadKeyTypeAsync>d__.<>1__state = -1;
			<ReadKeyTypeAsync>d__.<>t__builder.Start<RedisClient.<ReadKeyTypeAsync>d__38>(ref <ReadKeyTypeAsync>d__);
			return <ReadKeyTypeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyTTL(System.String)" />
		// Token: 0x060016B1 RID: 5809 RVA: 0x00074C54 File Offset: 0x00072E54
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadKeyTTLAsync(string key)
		{
			RedisClient.<ReadKeyTTLAsync>d__39 <ReadKeyTTLAsync>d__ = new RedisClient.<ReadKeyTTLAsync>d__39();
			<ReadKeyTTLAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadKeyTTLAsync>d__.<>4__this = this;
			<ReadKeyTTLAsync>d__.key = key;
			<ReadKeyTTLAsync>d__.<>1__state = -1;
			<ReadKeyTTLAsync>d__.<>t__builder.Start<RedisClient.<ReadKeyTTLAsync>d__39>(ref <ReadKeyTTLAsync>d__);
			return <ReadKeyTTLAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。
		/// 如果 key 不存在， APPEND 就简单地将给定 key 设为 value ，就像执行 SET key value 一样。
		/// 返回追加 value 之后， key 中字符串的长度。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数值</param>
		/// <returns>
		/// 追加 value 之后， key 中字符串的长度。
		/// </returns>
		// Token: 0x060016B2 RID: 5810 RVA: 0x00074C9F File Offset: 0x00072E9F
		public OperateResult<int> AppendKey(string key, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"APPEND",
				key,
				value
			});
		}

		/// <summary>
		/// 将 key 中储存的数字值减一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
		/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
		/// 本操作的值限制在 64 位(bit)有符号数字表示之内。
		/// 返回执行 DECR 命令之后 key 的值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>执行 DECR 命令之后 key 的值。</returns>
		// Token: 0x060016B3 RID: 5811 RVA: 0x00074CBD File Offset: 0x00072EBD
		public OperateResult<long> DecrementKey(string key)
		{
			return this.OperateLongNumberFromServer(new string[]
			{
				"DECR",
				key
			});
		}

		/// <summary>
		/// 将 key 所储存的值减去减量 decrement 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 DECR 操作。
		/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
		/// 本操作的值限制在 64 位(bit)有符号数字表示之内。
		/// 返回减去 decrement 之后， key 的值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">操作的值</param>
		/// <returns>返回减去 decrement 之后， key 的值。</returns>
		// Token: 0x060016B4 RID: 5812 RVA: 0x00074CD7 File Offset: 0x00072ED7
		public OperateResult<long> DecrementKey(string key, long value)
		{
			return this.OperateLongNumberFromServer(new string[]
			{
				"DECRBY",
				key,
				value.ToString()
			});
		}

		/// <summary>
		/// 返回 key 所关联的字符串值。如果 key 不存在那么返回特殊值 nil 。
		/// 假如 key 储存的值不是字符串类型，返回一个错误，因为 GET 只能用于处理字符串值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>当 key 不存在时，返回 nil ，否则，返回 key 的值。</returns>
		// Token: 0x060016B5 RID: 5813 RVA: 0x00074CFB File Offset: 0x00072EFB
		public OperateResult<string> ReadKey(string key)
		{
			return this.OperateStringFromServer(new string[]
			{
				"GET",
				key
			});
		}

		/// <summary>
		/// 返回 key 中字符串值的子字符串，字符串的截取范围由 start 和 end 两个偏移量决定(包括 start 和 end 在内)。
		/// 负数偏移量表示从字符串最后开始计数， -1 表示最后一个字符， -2 表示倒数第二个，以此类推。
		/// 返回截取得出的子字符串。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="start">截取开始的位置</param>
		/// <param name="end">截取结束的位置</param>
		/// <returns>返回截取得出的子字符串。</returns>
		// Token: 0x060016B6 RID: 5814 RVA: 0x00074D15 File Offset: 0x00072F15
		public OperateResult<string> ReadKeyRange(string key, int start, int end)
		{
			return this.OperateStringFromServer(new string[]
			{
				"GETRANGE",
				key,
				start.ToString(),
				end.ToString()
			});
		}

		/// <summary>
		/// 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。当 key 存在但不是字符串类型时，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">新的值</param>
		/// <returns>返回给定 key 的旧值。当 key 没有旧值时，也即是， key 不存在时，返回 nil 。</returns>
		// Token: 0x060016B7 RID: 5815 RVA: 0x00074D43 File Offset: 0x00072F43
		public OperateResult<string> ReadAndWriteKey(string key, string value)
		{
			return this.OperateStringFromServer(new string[]
			{
				"GETSET",
				key,
				value
			});
		}

		/// <summary>
		/// 将 key 中储存的数字值增一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
		/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
		/// 返回执行 INCR 命令之后 key 的值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>返回执行 INCR 命令之后 key 的值。</returns>
		// Token: 0x060016B8 RID: 5816 RVA: 0x00074D61 File Offset: 0x00072F61
		public OperateResult<long> IncrementKey(string key)
		{
			return this.OperateLongNumberFromServer(new string[]
			{
				"INCR",
				key
			});
		}

		/// <summary>
		/// 将 key 所储存的值加上增量 increment 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
		/// 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">增量数据</param>
		/// <returns>加上 increment 之后， key 的值。</returns>
		// Token: 0x060016B9 RID: 5817 RVA: 0x00074D7B File Offset: 0x00072F7B
		public OperateResult<long> IncrementKey(string key, long value)
		{
			return this.OperateLongNumberFromServer(new string[]
			{
				"INCRBY",
				key,
				value.ToString()
			});
		}

		/// <summary>
		/// 将 key 所储存的值加上增量 increment 。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCRBYFLOAT 操作。
		/// 如果命令执行成功，那么 key 的值会被更新为（执行加法之后的）新值，并且新值会以字符串的形式返回给调用者
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">增量数据</param>
		/// <returns>执行命令之后 key 的值。</returns>
		// Token: 0x060016BA RID: 5818 RVA: 0x00074D9F File Offset: 0x00072F9F
		public OperateResult<string> IncrementKey(string key, float value)
		{
			return this.OperateStringFromServer(new string[]
			{
				"INCRBYFLOAT",
				key,
				value.ToString()
			});
		}

		/// <summary>
		/// 返回所有(一个或多个)给定 key 的值。
		/// 如果给定的 key 里面，有某个 key 不存在，那么这个 key 返回特殊值 null 。因此，该命令永不失败。
		/// </summary>
		/// <param name="keys">关键字数组</param>
		/// <returns>一个包含所有给定 key 的值的列表。</returns>
		// Token: 0x060016BB RID: 5819 RVA: 0x00074DC3 File Offset: 0x00072FC3
		public OperateResult<string[]> ReadKey(string[] keys)
		{
			return this.OperateStringsFromServer(SoftBasic.SpliceStringArray("MGET", keys));
		}

		/// <summary>
		/// 同时设置一个或多个 key-value 对。
		/// 如果某个给定 key 已经存在，那么 MSET 会用新值覆盖原来的旧值，如果这不是你所希望的效果，请考虑使用 MSETNX 命令：它只会在所有给定 key 都不存在的情况下进行设置操作。
		/// </summary>
		/// <param name="keys">关键字数组</param>
		/// <param name="values">值数组</param>
		/// <returns>总是返回 OK (因为 MSET 不可能失败)</returns>
		// Token: 0x060016BC RID: 5820 RVA: 0x00074DD8 File Offset: 0x00072FD8
		public OperateResult WriteKey(string[] keys, string[] values)
		{
			bool flag = keys == null;
			if (flag)
			{
				throw new ArgumentNullException("keys");
			}
			bool flag2 = values == null;
			if (flag2)
			{
				throw new ArgumentNullException("values");
			}
			bool flag3 = keys.Length != values.Length;
			if (flag3)
			{
				throw new ArgumentException("Two arguement not same length");
			}
			List<string> list = new List<string>();
			list.Add("MSET");
			for (int i = 0; i < keys.Length; i++)
			{
				list.Add(keys[i]);
				list.Add(values[i]);
			}
			return this.OperateStatusFromServer(list.ToArray());
		}

		/// <summary>
		/// 将字符串值 value 关联到 key 。
		/// 如果 key 已经持有其他值， SET 就覆写旧值，无视类型。
		/// 对于某个原本带有生存时间（TTL）的键来说， 当 SET 命令成功在这个键上执行时， 这个键原有的 TTL 将被清除。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数据值</param>
		/// <returns> SET 在设置操作成功完成时，才返回 OK 。</returns>
		// Token: 0x060016BD RID: 5821 RVA: 0x00074E7A File Offset: 0x0007307A
		public OperateResult WriteKey(string key, string value)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"SET",
				key,
				value
			});
		}

		/// <summary>
		/// 将字符串值 value 关联到 key 。并发布一个订阅的频道数据，都成功时，才返回成功
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数据值</param>
		/// <returns>是否成功的结果对象</returns>
		// Token: 0x060016BE RID: 5822 RVA: 0x00074E98 File Offset: 0x00073098
		public OperateResult WriteAndPublishKey(string key, string value)
		{
			OperateResult operateResult = this.WriteKey(key, value);
			bool flag = !operateResult.IsSuccess;
			OperateResult result;
			if (flag)
			{
				result = operateResult;
			}
			else
			{
				result = this.Publish(key, value);
			}
			return result;
		}

		/// <summary>
		/// 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。如果 key 已经存在， SETEX 命令将覆写旧值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数值</param>
		/// <param name="seconds">生存时间，单位秒</param>
		/// <returns>设置成功时返回 OK 。当 seconds 参数不合法时，返回一个错误。</returns>
		// Token: 0x060016BF RID: 5823 RVA: 0x00074ECC File Offset: 0x000730CC
		public OperateResult WriteExpireKey(string key, string value, long seconds)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"SETEX",
				key,
				seconds.ToString(),
				value
			});
		}

		/// <summary>
		/// 将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 SETNX 不做任何动作。设置成功，返回 1 。设置失败，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数据值</param>
		/// <returns>设置成功，返回 1 。设置失败，返回 0 。</returns>
		// Token: 0x060016C0 RID: 5824 RVA: 0x00074EF4 File Offset: 0x000730F4
		public OperateResult<int> WriteKeyIfNotExists(string key, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"SETNX",
				key,
				value
			});
		}

		/// <summary>
		/// 用 value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始。不存在的 key 当作空白字符串处理。返回被 SETRANGE 修改之后，字符串的长度。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数值</param>
		/// <param name="offset">起始的偏移量</param>
		/// <returns>被 SETRANGE 修改之后，字符串的长度。</returns>
		// Token: 0x060016C1 RID: 5825 RVA: 0x00074F12 File Offset: 0x00073112
		public OperateResult<int> WriteKeyRange(string key, string value, int offset)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"SETRANGE",
				key,
				offset.ToString(),
				value
			});
		}

		/// <summary>
		/// 返回 key 所储存的字符串值的长度。当 key 储存的不是字符串值时，返回一个错误。返回符串值的长度。当 key 不存在时，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>字符串值的长度。当 key 不存在时，返回 0 。</returns>
		// Token: 0x060016C2 RID: 5826 RVA: 0x00074F3A File Offset: 0x0007313A
		public OperateResult<int> ReadKeyLength(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"STRLEN",
				key
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.AppendKey(System.String,System.String)" />
		// Token: 0x060016C3 RID: 5827 RVA: 0x00074F54 File Offset: 0x00073154
		[DebuggerStepThrough]
		public Task<OperateResult<int>> AppendKeyAsync(string key, string value)
		{
			RedisClient.<AppendKeyAsync>d__57 <AppendKeyAsync>d__ = new RedisClient.<AppendKeyAsync>d__57();
			<AppendKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<AppendKeyAsync>d__.<>4__this = this;
			<AppendKeyAsync>d__.key = key;
			<AppendKeyAsync>d__.value = value;
			<AppendKeyAsync>d__.<>1__state = -1;
			<AppendKeyAsync>d__.<>t__builder.Start<RedisClient.<AppendKeyAsync>d__57>(ref <AppendKeyAsync>d__);
			return <AppendKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DecrementKey(System.String)" />
		// Token: 0x060016C4 RID: 5828 RVA: 0x00074FA8 File Offset: 0x000731A8
		[DebuggerStepThrough]
		public Task<OperateResult<long>> DecrementKeyAsync(string key)
		{
			RedisClient.<DecrementKeyAsync>d__58 <DecrementKeyAsync>d__ = new RedisClient.<DecrementKeyAsync>d__58();
			<DecrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<DecrementKeyAsync>d__.<>4__this = this;
			<DecrementKeyAsync>d__.key = key;
			<DecrementKeyAsync>d__.<>1__state = -1;
			<DecrementKeyAsync>d__.<>t__builder.Start<RedisClient.<DecrementKeyAsync>d__58>(ref <DecrementKeyAsync>d__);
			return <DecrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DecrementKey(System.String,System.Int64)" />
		// Token: 0x060016C5 RID: 5829 RVA: 0x00074FF4 File Offset: 0x000731F4
		[DebuggerStepThrough]
		public Task<OperateResult<long>> DecrementKeyAsync(string key, long value)
		{
			RedisClient.<DecrementKeyAsync>d__59 <DecrementKeyAsync>d__ = new RedisClient.<DecrementKeyAsync>d__59();
			<DecrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<DecrementKeyAsync>d__.<>4__this = this;
			<DecrementKeyAsync>d__.key = key;
			<DecrementKeyAsync>d__.value = value;
			<DecrementKeyAsync>d__.<>1__state = -1;
			<DecrementKeyAsync>d__.<>t__builder.Start<RedisClient.<DecrementKeyAsync>d__59>(ref <DecrementKeyAsync>d__);
			return <DecrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKey(System.String)" />
		// Token: 0x060016C6 RID: 5830 RVA: 0x00075048 File Offset: 0x00073248
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadKeyAsync(string key)
		{
			RedisClient.<ReadKeyAsync>d__60 <ReadKeyAsync>d__ = new RedisClient.<ReadKeyAsync>d__60();
			<ReadKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadKeyAsync>d__.<>4__this = this;
			<ReadKeyAsync>d__.key = key;
			<ReadKeyAsync>d__.<>1__state = -1;
			<ReadKeyAsync>d__.<>t__builder.Start<RedisClient.<ReadKeyAsync>d__60>(ref <ReadKeyAsync>d__);
			return <ReadKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyRange(System.String,System.Int32,System.Int32)" />
		// Token: 0x060016C7 RID: 5831 RVA: 0x00075094 File Offset: 0x00073294
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadKeyRangeAsync(string key, int start, int end)
		{
			RedisClient.<ReadKeyRangeAsync>d__61 <ReadKeyRangeAsync>d__ = new RedisClient.<ReadKeyRangeAsync>d__61();
			<ReadKeyRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadKeyRangeAsync>d__.<>4__this = this;
			<ReadKeyRangeAsync>d__.key = key;
			<ReadKeyRangeAsync>d__.start = start;
			<ReadKeyRangeAsync>d__.end = end;
			<ReadKeyRangeAsync>d__.<>1__state = -1;
			<ReadKeyRangeAsync>d__.<>t__builder.Start<RedisClient.<ReadKeyRangeAsync>d__61>(ref <ReadKeyRangeAsync>d__);
			return <ReadKeyRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadAndWriteKey(System.String,System.String)" />
		// Token: 0x060016C8 RID: 5832 RVA: 0x000750F0 File Offset: 0x000732F0
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadAndWriteKeyAsync(string key, string value)
		{
			RedisClient.<ReadAndWriteKeyAsync>d__62 <ReadAndWriteKeyAsync>d__ = new RedisClient.<ReadAndWriteKeyAsync>d__62();
			<ReadAndWriteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadAndWriteKeyAsync>d__.<>4__this = this;
			<ReadAndWriteKeyAsync>d__.key = key;
			<ReadAndWriteKeyAsync>d__.value = value;
			<ReadAndWriteKeyAsync>d__.<>1__state = -1;
			<ReadAndWriteKeyAsync>d__.<>t__builder.Start<RedisClient.<ReadAndWriteKeyAsync>d__62>(ref <ReadAndWriteKeyAsync>d__);
			return <ReadAndWriteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementKey(System.String)" />
		// Token: 0x060016C9 RID: 5833 RVA: 0x00075144 File Offset: 0x00073344
		[DebuggerStepThrough]
		public Task<OperateResult<long>> IncrementKeyAsync(string key)
		{
			RedisClient.<IncrementKeyAsync>d__63 <IncrementKeyAsync>d__ = new RedisClient.<IncrementKeyAsync>d__63();
			<IncrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<IncrementKeyAsync>d__.<>4__this = this;
			<IncrementKeyAsync>d__.key = key;
			<IncrementKeyAsync>d__.<>1__state = -1;
			<IncrementKeyAsync>d__.<>t__builder.Start<RedisClient.<IncrementKeyAsync>d__63>(ref <IncrementKeyAsync>d__);
			return <IncrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementKey(System.String,System.Int64)" />
		// Token: 0x060016CA RID: 5834 RVA: 0x00075190 File Offset: 0x00073390
		[DebuggerStepThrough]
		public Task<OperateResult<long>> IncrementKeyAsync(string key, long value)
		{
			RedisClient.<IncrementKeyAsync>d__64 <IncrementKeyAsync>d__ = new RedisClient.<IncrementKeyAsync>d__64();
			<IncrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<IncrementKeyAsync>d__.<>4__this = this;
			<IncrementKeyAsync>d__.key = key;
			<IncrementKeyAsync>d__.value = value;
			<IncrementKeyAsync>d__.<>1__state = -1;
			<IncrementKeyAsync>d__.<>t__builder.Start<RedisClient.<IncrementKeyAsync>d__64>(ref <IncrementKeyAsync>d__);
			return <IncrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementKey(System.String,System.Single)" />
		// Token: 0x060016CB RID: 5835 RVA: 0x000751E4 File Offset: 0x000733E4
		[DebuggerStepThrough]
		public Task<OperateResult<string>> IncrementKeyAsync(string key, float value)
		{
			RedisClient.<IncrementKeyAsync>d__65 <IncrementKeyAsync>d__ = new RedisClient.<IncrementKeyAsync>d__65();
			<IncrementKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<IncrementKeyAsync>d__.<>4__this = this;
			<IncrementKeyAsync>d__.key = key;
			<IncrementKeyAsync>d__.value = value;
			<IncrementKeyAsync>d__.<>1__state = -1;
			<IncrementKeyAsync>d__.<>t__builder.Start<RedisClient.<IncrementKeyAsync>d__65>(ref <IncrementKeyAsync>d__);
			return <IncrementKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKey(System.String[])" />
		// Token: 0x060016CC RID: 5836 RVA: 0x00075238 File Offset: 0x00073438
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadKeyAsync(string[] keys)
		{
			RedisClient.<ReadKeyAsync>d__66 <ReadKeyAsync>d__ = new RedisClient.<ReadKeyAsync>d__66();
			<ReadKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadKeyAsync>d__.<>4__this = this;
			<ReadKeyAsync>d__.keys = keys;
			<ReadKeyAsync>d__.<>1__state = -1;
			<ReadKeyAsync>d__.<>t__builder.Start<RedisClient.<ReadKeyAsync>d__66>(ref <ReadKeyAsync>d__);
			return <ReadKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKey(System.String[],System.String[])" />
		// Token: 0x060016CD RID: 5837 RVA: 0x00075284 File Offset: 0x00073484
		[DebuggerStepThrough]
		public Task<OperateResult> WriteKeyAsync(string[] keys, string[] values)
		{
			RedisClient.<WriteKeyAsync>d__67 <WriteKeyAsync>d__ = new RedisClient.<WriteKeyAsync>d__67();
			<WriteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteKeyAsync>d__.<>4__this = this;
			<WriteKeyAsync>d__.keys = keys;
			<WriteKeyAsync>d__.values = values;
			<WriteKeyAsync>d__.<>1__state = -1;
			<WriteKeyAsync>d__.<>t__builder.Start<RedisClient.<WriteKeyAsync>d__67>(ref <WriteKeyAsync>d__);
			return <WriteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKey(System.String,System.String)" />
		// Token: 0x060016CE RID: 5838 RVA: 0x000752D8 File Offset: 0x000734D8
		[DebuggerStepThrough]
		public Task<OperateResult> WriteKeyAsync(string key, string value)
		{
			RedisClient.<WriteKeyAsync>d__68 <WriteKeyAsync>d__ = new RedisClient.<WriteKeyAsync>d__68();
			<WriteKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteKeyAsync>d__.<>4__this = this;
			<WriteKeyAsync>d__.key = key;
			<WriteKeyAsync>d__.value = value;
			<WriteKeyAsync>d__.<>1__state = -1;
			<WriteKeyAsync>d__.<>t__builder.Start<RedisClient.<WriteKeyAsync>d__68>(ref <WriteKeyAsync>d__);
			return <WriteKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteAndPublishKey(System.String,System.String)" />
		// Token: 0x060016CF RID: 5839 RVA: 0x0007532C File Offset: 0x0007352C
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAndPublishKeyAsync(string key, string value)
		{
			RedisClient.<WriteAndPublishKeyAsync>d__69 <WriteAndPublishKeyAsync>d__ = new RedisClient.<WriteAndPublishKeyAsync>d__69();
			<WriteAndPublishKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAndPublishKeyAsync>d__.<>4__this = this;
			<WriteAndPublishKeyAsync>d__.key = key;
			<WriteAndPublishKeyAsync>d__.value = value;
			<WriteAndPublishKeyAsync>d__.<>1__state = -1;
			<WriteAndPublishKeyAsync>d__.<>t__builder.Start<RedisClient.<WriteAndPublishKeyAsync>d__69>(ref <WriteAndPublishKeyAsync>d__);
			return <WriteAndPublishKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteExpireKey(System.String,System.String,System.Int64)" />
		// Token: 0x060016D0 RID: 5840 RVA: 0x00075380 File Offset: 0x00073580
		[DebuggerStepThrough]
		public Task<OperateResult> WriteExpireKeyAsync(string key, string value, long seconds)
		{
			RedisClient.<WriteExpireKeyAsync>d__70 <WriteExpireKeyAsync>d__ = new RedisClient.<WriteExpireKeyAsync>d__70();
			<WriteExpireKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteExpireKeyAsync>d__.<>4__this = this;
			<WriteExpireKeyAsync>d__.key = key;
			<WriteExpireKeyAsync>d__.value = value;
			<WriteExpireKeyAsync>d__.seconds = seconds;
			<WriteExpireKeyAsync>d__.<>1__state = -1;
			<WriteExpireKeyAsync>d__.<>t__builder.Start<RedisClient.<WriteExpireKeyAsync>d__70>(ref <WriteExpireKeyAsync>d__);
			return <WriteExpireKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKeyIfNotExists(System.String,System.String)" />
		// Token: 0x060016D1 RID: 5841 RVA: 0x000753DC File Offset: 0x000735DC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteKeyIfNotExistsAsync(string key, string value)
		{
			RedisClient.<WriteKeyIfNotExistsAsync>d__71 <WriteKeyIfNotExistsAsync>d__ = new RedisClient.<WriteKeyIfNotExistsAsync>d__71();
			<WriteKeyIfNotExistsAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteKeyIfNotExistsAsync>d__.<>4__this = this;
			<WriteKeyIfNotExistsAsync>d__.key = key;
			<WriteKeyIfNotExistsAsync>d__.value = value;
			<WriteKeyIfNotExistsAsync>d__.<>1__state = -1;
			<WriteKeyIfNotExistsAsync>d__.<>t__builder.Start<RedisClient.<WriteKeyIfNotExistsAsync>d__71>(ref <WriteKeyIfNotExistsAsync>d__);
			return <WriteKeyIfNotExistsAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteKeyRange(System.String,System.String,System.Int32)" />
		// Token: 0x060016D2 RID: 5842 RVA: 0x00075430 File Offset: 0x00073630
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteKeyRangeAsync(string key, string value, int offset)
		{
			RedisClient.<WriteKeyRangeAsync>d__72 <WriteKeyRangeAsync>d__ = new RedisClient.<WriteKeyRangeAsync>d__72();
			<WriteKeyRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteKeyRangeAsync>d__.<>4__this = this;
			<WriteKeyRangeAsync>d__.key = key;
			<WriteKeyRangeAsync>d__.value = value;
			<WriteKeyRangeAsync>d__.offset = offset;
			<WriteKeyRangeAsync>d__.<>1__state = -1;
			<WriteKeyRangeAsync>d__.<>t__builder.Start<RedisClient.<WriteKeyRangeAsync>d__72>(ref <WriteKeyRangeAsync>d__);
			return <WriteKeyRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadKeyLength(System.String)" />
		// Token: 0x060016D3 RID: 5843 RVA: 0x0007548C File Offset: 0x0007368C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadKeyLengthAsync(string key)
		{
			RedisClient.<ReadKeyLengthAsync>d__73 <ReadKeyLengthAsync>d__ = new RedisClient.<ReadKeyLengthAsync>d__73();
			<ReadKeyLengthAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadKeyLengthAsync>d__.<>4__this = this;
			<ReadKeyLengthAsync>d__.key = key;
			<ReadKeyLengthAsync>d__.<>1__state = -1;
			<ReadKeyLengthAsync>d__.<>t__builder.Start<RedisClient.<ReadKeyLengthAsync>d__73>(ref <ReadKeyLengthAsync>d__);
			return <ReadKeyLengthAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 将值 value 插入到列表 key 当中，位于值 pivot 之前。
		/// 当 pivot 不存在于列表 key 时，不执行任何操作。
		/// 当 key 不存在时， key 被视为空列表，不执行任何操作。
		/// 如果 key 不是列表类型，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数值</param>
		/// <param name="pivot">原先的值</param>
		/// <returns>
		/// 如果命令执行成功，返回插入操作完成之后，列表的长度。
		/// 如果没有找到 pivot ，返回 -1 。
		/// 如果 key 不存在或为空列表，返回 0 。
		/// </returns>
		// Token: 0x060016D4 RID: 5844 RVA: 0x000754D7 File Offset: 0x000736D7
		public OperateResult<int> ListInsertBefore(string key, string value, string pivot)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"LINSERT",
				key,
				"BEFORE",
				pivot,
				value
			});
		}

		/// <summary>
		/// 将值 value 插入到列表 key 当中，位于值 pivot 之后。
		/// 当 pivot 不存在于列表 key 时，不执行任何操作。
		/// 当 key 不存在时， key 被视为空列表，不执行任何操作。
		/// 如果 key 不是列表类型，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">数值</param>
		/// <param name="pivot">原先的值</param>
		/// <returns>
		/// 如果命令执行成功，返回插入操作完成之后，列表的长度。
		/// 如果没有找到 pivot ，返回 -1 。
		/// 如果 key 不存在或为空列表，返回 0 。
		/// </returns>
		// Token: 0x060016D5 RID: 5845 RVA: 0x00075501 File Offset: 0x00073701
		public OperateResult<int> ListInsertAfter(string key, string value, string pivot)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"LINSERT",
				key,
				"AFTER",
				pivot,
				value
			});
		}

		/// <summary>
		/// 返回列表 key 的长度。如果 key 不存在，则 key 被解释为一个空列表，返回 0 .如果 key 不是列表类型，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>列表 key 的长度。</returns>
		// Token: 0x060016D6 RID: 5846 RVA: 0x0007552B File Offset: 0x0007372B
		public OperateResult<int> GetListLength(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"LLEN",
				key
			});
		}

		/// <summary>
		/// 返回列表 key 中，下标为 index 的元素。下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
		/// 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。如果 key 不是列表类型，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="index">索引位置</param>
		/// <returns>列表中下标为 index 的元素。如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。</returns>
		// Token: 0x060016D7 RID: 5847 RVA: 0x00075545 File Offset: 0x00073745
		public OperateResult<string> ReadListByIndex(string key, long index)
		{
			return this.OperateStringFromServer(new string[]
			{
				"LINDEX",
				key,
				index.ToString()
			});
		}

		/// <summary>
		/// 移除并返回列表 key 的头元素。列表的头元素。当 key 不存在时，返回 nil 。
		/// </summary>
		/// <param name="key">关键字信息</param>
		/// <returns>列表的头元素。</returns>
		// Token: 0x060016D8 RID: 5848 RVA: 0x00075569 File Offset: 0x00073769
		public OperateResult<string> ListLeftPop(string key)
		{
			return this.OperateStringFromServer(new string[]
			{
				"LPOP",
				key
			});
		}

		/// <summary>
		/// 将一个或多个值 value 插入到列表 key 的表头，如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。返回执行 LPUSH 命令后，列表的长度。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">值</param>
		/// <returns>执行 LPUSH 命令后，列表的长度。</returns>
		// Token: 0x060016D9 RID: 5849 RVA: 0x00075583 File Offset: 0x00073783
		public OperateResult<int> ListLeftPush(string key, string value)
		{
			return this.ListLeftPush(key, new string[]
			{
				value
			});
		}

		/// <summary>
		/// 将一个或多个值 value 插入到列表 key 的表头，如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。返回执行 LPUSH 命令后，列表的长度。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="values">值</param>
		/// <returns>执行 LPUSH 命令后，列表的长度。</returns>
		// Token: 0x060016DA RID: 5850 RVA: 0x00075596 File Offset: 0x00073796
		public OperateResult<int> ListLeftPush(string key, string[] values)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("LPUSH", key, values));
		}

		/// <summary>
		/// 将值 value 插入到列表 key 的表头，当且仅当 key 存在并且是一个列表。和 LPUSH 命令相反，当 key 不存在时， LPUSHX 命令什么也不做。
		/// 返回LPUSHX 命令执行之后，表的长度。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">值</param>
		/// <returns>是否插入数据成功</returns>
		// Token: 0x060016DB RID: 5851 RVA: 0x000755AA File Offset: 0x000737AA
		public OperateResult<int> ListLeftPushX(string key, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"LPUSHX",
				key,
				value
			});
		}

		/// <summary>
		/// 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。
		/// 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
		/// 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
		/// 返回一个列表，包含指定区间内的元素。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="start">开始的索引</param>
		/// <param name="stop">结束的索引</param>
		/// <returns>返回一个列表，包含指定区间内的元素。</returns>
		// Token: 0x060016DC RID: 5852 RVA: 0x000755C8 File Offset: 0x000737C8
		public OperateResult<string[]> ListRange(string key, long start, long stop)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"LRANGE",
				key,
				start.ToString(),
				stop.ToString()
			});
		}

		/// <summary>
		/// 根据参数 count 的值，移除列表中与参数 value 相等的元素。count 的值可以是以下几种：
		/// count &gt; 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
		/// count &lt; 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
		/// count = 0 : 移除表中所有与 value 相等的值。
		/// 返回被移除的数量。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="count">移除参数</param>
		/// <param name="value">匹配的值</param>
		/// <returns>被移除元素的数量。因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。</returns>
		// Token: 0x060016DD RID: 5853 RVA: 0x000755F6 File Offset: 0x000737F6
		public OperateResult<int> ListRemoveElementMatch(string key, long count, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"LREM",
				key,
				count.ToString(),
				value
			});
		}

		/// <summary>
		/// 设置数组的某一个索引的数据信息，当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="index">索引位置</param>
		/// <param name="value">值</param>
		/// <returns>操作成功返回 ok ，否则返回错误信息。</returns>
		// Token: 0x060016DE RID: 5854 RVA: 0x0007561E File Offset: 0x0007381E
		public OperateResult ListSet(string key, long index, string value)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"LSET",
				key.ToString(),
				index.ToString(),
				value
			});
		}

		/// <summary>
		/// 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。
		/// 举个例子，执行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三个元素，其余元素全部删除。
		/// 下标( index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
		/// 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
		/// 当 key 不是列表类型时，返回一个错误。
		/// </summary>
		/// <param name="key">关键字信息</param>
		/// <param name="start">起始的索引信息</param>
		/// <param name="end">结束的索引信息</param>
		/// <returns>操作成功返回 ok ，否则返回错误信息。</returns>
		// Token: 0x060016DF RID: 5855 RVA: 0x0007564B File Offset: 0x0007384B
		public OperateResult ListTrim(string key, long start, long end)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"LTRIM",
				key,
				start.ToString(),
				end.ToString()
			});
		}

		/// <summary>
		/// 移除并返回列表 key 的尾元素。当 key 不存在时，返回 nil 。
		/// </summary>
		/// <param name="key">关键字信息</param>
		/// <returns>列表的尾元素。</returns>
		// Token: 0x060016E0 RID: 5856 RVA: 0x00075679 File Offset: 0x00073879
		public OperateResult<string> ListRightPop(string key)
		{
			return this.OperateStringFromServer(new string[]
			{
				"RPOP",
				key
			});
		}

		/// <summary>
		/// 命令 RPOPLPUSH 在一个原子时间内，执行以下两个动作：<br />
		/// 1. 将列表 source 中的最后一个元素( 尾元素)弹出，并返回给客户端。<br />
		/// 2. 将 source 弹出的元素插入到列表 destination ，作为 destination 列表的的头元素。<br /><br />
		/// 举个例子，你有两个列表 source 和 destination ， source 列表有元素 a, b, c ， destination 列表有元素 x, y, z ，执行 RPOPLPUSH source destination 之后， source 列表包含元素 a, b ， destination 列表包含元素 c, x, y, z ，并且元素 c 会被返回给客户端。
		/// 如果 source 不存在，值 nil 被返回，并且不执行其他动作。
		/// 如果 source 和 destination 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转( rotation)操作。
		/// </summary>
		/// <param name="key1">第一个关键字</param>
		/// <param name="key2">第二个关键字</param>
		/// <returns>返回的移除的对象</returns>
		// Token: 0x060016E1 RID: 5857 RVA: 0x00075693 File Offset: 0x00073893
		public OperateResult<string> ListRightPopLeftPush(string key1, string key2)
		{
			return this.OperateStringFromServer(new string[]
			{
				"RPOPLPUSH",
				key1,
				key2
			});
		}

		/// <summary>
		/// 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
		/// 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">值</param>
		/// <returns>返回执行 RPUSH 操作后，表的长度。</returns>
		// Token: 0x060016E2 RID: 5858 RVA: 0x000756B1 File Offset: 0x000738B1
		public OperateResult<int> ListRightPush(string key, string value)
		{
			return this.ListRightPush(key, new string[]
			{
				value
			});
		}

		/// <summary>
		/// 将一个或多个值 value 插入到列表 key 的表尾(最右边)。
		/// 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，
		/// 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。
		/// 返回执行 RPUSH 操作后，表的长度。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="values">值</param>
		/// <returns>返回执行 RPUSH 操作后，表的长度。</returns>
		// Token: 0x060016E3 RID: 5859 RVA: 0x000756C4 File Offset: 0x000738C4
		public OperateResult<int> ListRightPush(string key, string[] values)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("RPUSH", key, values));
		}

		/// <summary>
		/// 将值 value 插入到列表 key 的表尾，当且仅当 key 存在并且是一个列表。
		/// 和 RPUSH 命令相反，当 key 不存在时， RPUSHX 命令什么也不做。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="value">值</param>
		/// <returns>RPUSHX 命令执行之后，表的长度。</returns>
		// Token: 0x060016E4 RID: 5860 RVA: 0x000756D8 File Offset: 0x000738D8
		public OperateResult<int> ListRightPushX(string key, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"RPUSHX",
				key,
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListInsertBefore(System.String,System.String,System.String)" />
		// Token: 0x060016E5 RID: 5861 RVA: 0x000756F8 File Offset: 0x000738F8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListInsertBeforeAsync(string key, string value, string pivot)
		{
			RedisClient.<ListInsertBeforeAsync>d__91 <ListInsertBeforeAsync>d__ = new RedisClient.<ListInsertBeforeAsync>d__91();
			<ListInsertBeforeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListInsertBeforeAsync>d__.<>4__this = this;
			<ListInsertBeforeAsync>d__.key = key;
			<ListInsertBeforeAsync>d__.value = value;
			<ListInsertBeforeAsync>d__.pivot = pivot;
			<ListInsertBeforeAsync>d__.<>1__state = -1;
			<ListInsertBeforeAsync>d__.<>t__builder.Start<RedisClient.<ListInsertBeforeAsync>d__91>(ref <ListInsertBeforeAsync>d__);
			return <ListInsertBeforeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListInsertAfter(System.String,System.String,System.String)" />
		// Token: 0x060016E6 RID: 5862 RVA: 0x00075754 File Offset: 0x00073954
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListInsertAfterAsync(string key, string value, string pivot)
		{
			RedisClient.<ListInsertAfterAsync>d__92 <ListInsertAfterAsync>d__ = new RedisClient.<ListInsertAfterAsync>d__92();
			<ListInsertAfterAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListInsertAfterAsync>d__.<>4__this = this;
			<ListInsertAfterAsync>d__.key = key;
			<ListInsertAfterAsync>d__.value = value;
			<ListInsertAfterAsync>d__.pivot = pivot;
			<ListInsertAfterAsync>d__.<>1__state = -1;
			<ListInsertAfterAsync>d__.<>t__builder.Start<RedisClient.<ListInsertAfterAsync>d__92>(ref <ListInsertAfterAsync>d__);
			return <ListInsertAfterAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.GetListLength(System.String)" />
		// Token: 0x060016E7 RID: 5863 RVA: 0x000757B0 File Offset: 0x000739B0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> GetListLengthAsync(string key)
		{
			RedisClient.<GetListLengthAsync>d__93 <GetListLengthAsync>d__ = new RedisClient.<GetListLengthAsync>d__93();
			<GetListLengthAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<GetListLengthAsync>d__.<>4__this = this;
			<GetListLengthAsync>d__.key = key;
			<GetListLengthAsync>d__.<>1__state = -1;
			<GetListLengthAsync>d__.<>t__builder.Start<RedisClient.<GetListLengthAsync>d__93>(ref <GetListLengthAsync>d__);
			return <GetListLengthAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadListByIndex(System.String,System.Int64)" />
		// Token: 0x060016E8 RID: 5864 RVA: 0x000757FC File Offset: 0x000739FC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadListByIndexAsync(string key, long index)
		{
			RedisClient.<ReadListByIndexAsync>d__94 <ReadListByIndexAsync>d__ = new RedisClient.<ReadListByIndexAsync>d__94();
			<ReadListByIndexAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadListByIndexAsync>d__.<>4__this = this;
			<ReadListByIndexAsync>d__.key = key;
			<ReadListByIndexAsync>d__.index = index;
			<ReadListByIndexAsync>d__.<>1__state = -1;
			<ReadListByIndexAsync>d__.<>t__builder.Start<RedisClient.<ReadListByIndexAsync>d__94>(ref <ReadListByIndexAsync>d__);
			return <ReadListByIndexAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPop(System.String)" />
		// Token: 0x060016E9 RID: 5865 RVA: 0x00075850 File Offset: 0x00073A50
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ListLeftPopAsync(string key)
		{
			RedisClient.<ListLeftPopAsync>d__95 <ListLeftPopAsync>d__ = new RedisClient.<ListLeftPopAsync>d__95();
			<ListLeftPopAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ListLeftPopAsync>d__.<>4__this = this;
			<ListLeftPopAsync>d__.key = key;
			<ListLeftPopAsync>d__.<>1__state = -1;
			<ListLeftPopAsync>d__.<>t__builder.Start<RedisClient.<ListLeftPopAsync>d__95>(ref <ListLeftPopAsync>d__);
			return <ListLeftPopAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPush(System.String,System.String)" />
		// Token: 0x060016EA RID: 5866 RVA: 0x0007589C File Offset: 0x00073A9C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListLeftPushAsync(string key, string value)
		{
			RedisClient.<ListLeftPushAsync>d__96 <ListLeftPushAsync>d__ = new RedisClient.<ListLeftPushAsync>d__96();
			<ListLeftPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListLeftPushAsync>d__.<>4__this = this;
			<ListLeftPushAsync>d__.key = key;
			<ListLeftPushAsync>d__.value = value;
			<ListLeftPushAsync>d__.<>1__state = -1;
			<ListLeftPushAsync>d__.<>t__builder.Start<RedisClient.<ListLeftPushAsync>d__96>(ref <ListLeftPushAsync>d__);
			return <ListLeftPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPush(System.String,System.String[])" />
		// Token: 0x060016EB RID: 5867 RVA: 0x000758F0 File Offset: 0x00073AF0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListLeftPushAsync(string key, string[] values)
		{
			RedisClient.<ListLeftPushAsync>d__97 <ListLeftPushAsync>d__ = new RedisClient.<ListLeftPushAsync>d__97();
			<ListLeftPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListLeftPushAsync>d__.<>4__this = this;
			<ListLeftPushAsync>d__.key = key;
			<ListLeftPushAsync>d__.values = values;
			<ListLeftPushAsync>d__.<>1__state = -1;
			<ListLeftPushAsync>d__.<>t__builder.Start<RedisClient.<ListLeftPushAsync>d__97>(ref <ListLeftPushAsync>d__);
			return <ListLeftPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListLeftPushX(System.String,System.String)" />
		// Token: 0x060016EC RID: 5868 RVA: 0x00075944 File Offset: 0x00073B44
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListLeftPushXAsync(string key, string value)
		{
			RedisClient.<ListLeftPushXAsync>d__98 <ListLeftPushXAsync>d__ = new RedisClient.<ListLeftPushXAsync>d__98();
			<ListLeftPushXAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListLeftPushXAsync>d__.<>4__this = this;
			<ListLeftPushXAsync>d__.key = key;
			<ListLeftPushXAsync>d__.value = value;
			<ListLeftPushXAsync>d__.<>1__state = -1;
			<ListLeftPushXAsync>d__.<>t__builder.Start<RedisClient.<ListLeftPushXAsync>d__98>(ref <ListLeftPushXAsync>d__);
			return <ListLeftPushXAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRange(System.String,System.Int64,System.Int64)" />
		// Token: 0x060016ED RID: 5869 RVA: 0x00075998 File Offset: 0x00073B98
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ListRangeAsync(string key, long start, long stop)
		{
			RedisClient.<ListRangeAsync>d__99 <ListRangeAsync>d__ = new RedisClient.<ListRangeAsync>d__99();
			<ListRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ListRangeAsync>d__.<>4__this = this;
			<ListRangeAsync>d__.key = key;
			<ListRangeAsync>d__.start = start;
			<ListRangeAsync>d__.stop = stop;
			<ListRangeAsync>d__.<>1__state = -1;
			<ListRangeAsync>d__.<>t__builder.Start<RedisClient.<ListRangeAsync>d__99>(ref <ListRangeAsync>d__);
			return <ListRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRemoveElementMatch(System.String,System.Int64,System.String)" />
		// Token: 0x060016EE RID: 5870 RVA: 0x000759F4 File Offset: 0x00073BF4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRemoveElementMatchAsync(string key, long count, string value)
		{
			RedisClient.<ListRemoveElementMatchAsync>d__100 <ListRemoveElementMatchAsync>d__ = new RedisClient.<ListRemoveElementMatchAsync>d__100();
			<ListRemoveElementMatchAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRemoveElementMatchAsync>d__.<>4__this = this;
			<ListRemoveElementMatchAsync>d__.key = key;
			<ListRemoveElementMatchAsync>d__.count = count;
			<ListRemoveElementMatchAsync>d__.value = value;
			<ListRemoveElementMatchAsync>d__.<>1__state = -1;
			<ListRemoveElementMatchAsync>d__.<>t__builder.Start<RedisClient.<ListRemoveElementMatchAsync>d__100>(ref <ListRemoveElementMatchAsync>d__);
			return <ListRemoveElementMatchAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListSet(System.String,System.Int64,System.String)" />
		// Token: 0x060016EF RID: 5871 RVA: 0x00075A50 File Offset: 0x00073C50
		[DebuggerStepThrough]
		public Task<OperateResult> ListSetAsync(string key, long index, string value)
		{
			RedisClient.<ListSetAsync>d__101 <ListSetAsync>d__ = new RedisClient.<ListSetAsync>d__101();
			<ListSetAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ListSetAsync>d__.<>4__this = this;
			<ListSetAsync>d__.key = key;
			<ListSetAsync>d__.index = index;
			<ListSetAsync>d__.value = value;
			<ListSetAsync>d__.<>1__state = -1;
			<ListSetAsync>d__.<>t__builder.Start<RedisClient.<ListSetAsync>d__101>(ref <ListSetAsync>d__);
			return <ListSetAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListTrim(System.String,System.Int64,System.Int64)" />
		// Token: 0x060016F0 RID: 5872 RVA: 0x00075AAC File Offset: 0x00073CAC
		[DebuggerStepThrough]
		public Task<OperateResult> ListTrimAsync(string key, long start, long end)
		{
			RedisClient.<ListTrimAsync>d__102 <ListTrimAsync>d__ = new RedisClient.<ListTrimAsync>d__102();
			<ListTrimAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ListTrimAsync>d__.<>4__this = this;
			<ListTrimAsync>d__.key = key;
			<ListTrimAsync>d__.start = start;
			<ListTrimAsync>d__.end = end;
			<ListTrimAsync>d__.<>1__state = -1;
			<ListTrimAsync>d__.<>t__builder.Start<RedisClient.<ListTrimAsync>d__102>(ref <ListTrimAsync>d__);
			return <ListTrimAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPop(System.String)" />
		// Token: 0x060016F1 RID: 5873 RVA: 0x00075B08 File Offset: 0x00073D08
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ListRightPopAsync(string key)
		{
			RedisClient.<ListRightPopAsync>d__103 <ListRightPopAsync>d__ = new RedisClient.<ListRightPopAsync>d__103();
			<ListRightPopAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ListRightPopAsync>d__.<>4__this = this;
			<ListRightPopAsync>d__.key = key;
			<ListRightPopAsync>d__.<>1__state = -1;
			<ListRightPopAsync>d__.<>t__builder.Start<RedisClient.<ListRightPopAsync>d__103>(ref <ListRightPopAsync>d__);
			return <ListRightPopAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPopLeftPush(System.String,System.String)" />
		// Token: 0x060016F2 RID: 5874 RVA: 0x00075B54 File Offset: 0x00073D54
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ListRightPopLeftPushAsync(string key1, string key2)
		{
			RedisClient.<ListRightPopLeftPushAsync>d__104 <ListRightPopLeftPushAsync>d__ = new RedisClient.<ListRightPopLeftPushAsync>d__104();
			<ListRightPopLeftPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ListRightPopLeftPushAsync>d__.<>4__this = this;
			<ListRightPopLeftPushAsync>d__.key1 = key1;
			<ListRightPopLeftPushAsync>d__.key2 = key2;
			<ListRightPopLeftPushAsync>d__.<>1__state = -1;
			<ListRightPopLeftPushAsync>d__.<>t__builder.Start<RedisClient.<ListRightPopLeftPushAsync>d__104>(ref <ListRightPopLeftPushAsync>d__);
			return <ListRightPopLeftPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPush(System.String,System.String)" />
		// Token: 0x060016F3 RID: 5875 RVA: 0x00075BA8 File Offset: 0x00073DA8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRightPushAsync(string key, string value)
		{
			RedisClient.<ListRightPushAsync>d__105 <ListRightPushAsync>d__ = new RedisClient.<ListRightPushAsync>d__105();
			<ListRightPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRightPushAsync>d__.<>4__this = this;
			<ListRightPushAsync>d__.key = key;
			<ListRightPushAsync>d__.value = value;
			<ListRightPushAsync>d__.<>1__state = -1;
			<ListRightPushAsync>d__.<>t__builder.Start<RedisClient.<ListRightPushAsync>d__105>(ref <ListRightPushAsync>d__);
			return <ListRightPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPush(System.String,System.String[])" />
		// Token: 0x060016F4 RID: 5876 RVA: 0x00075BFC File Offset: 0x00073DFC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRightPushAsync(string key, string[] values)
		{
			RedisClient.<ListRightPushAsync>d__106 <ListRightPushAsync>d__ = new RedisClient.<ListRightPushAsync>d__106();
			<ListRightPushAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRightPushAsync>d__.<>4__this = this;
			<ListRightPushAsync>d__.key = key;
			<ListRightPushAsync>d__.values = values;
			<ListRightPushAsync>d__.<>1__state = -1;
			<ListRightPushAsync>d__.<>t__builder.Start<RedisClient.<ListRightPushAsync>d__106>(ref <ListRightPushAsync>d__);
			return <ListRightPushAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ListRightPushX(System.String,System.String)" />
		// Token: 0x060016F5 RID: 5877 RVA: 0x00075C50 File Offset: 0x00073E50
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ListRightPushXAsync(string key, string value)
		{
			RedisClient.<ListRightPushXAsync>d__107 <ListRightPushXAsync>d__ = new RedisClient.<ListRightPushXAsync>d__107();
			<ListRightPushXAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ListRightPushXAsync>d__.<>4__this = this;
			<ListRightPushXAsync>d__.key = key;
			<ListRightPushXAsync>d__.value = value;
			<ListRightPushXAsync>d__.<>1__state = -1;
			<ListRightPushXAsync>d__.<>t__builder.Start<RedisClient.<ListRightPushXAsync>d__107>(ref <ListRightPushXAsync>d__);
			return <ListRightPushXAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="field">域</param>
		/// <returns>被成功移除的域的数量，不包括被忽略的域。</returns>
		// Token: 0x060016F6 RID: 5878 RVA: 0x00075CA2 File Offset: 0x00073EA2
		public OperateResult<int> DeleteHashKey(string key, string field)
		{
			return this.DeleteHashKey(key, new string[]
			{
				field
			});
		}

		/// <summary>
		/// 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。返回被成功移除的域的数量，不包括被忽略的域。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="fields">所有的域</param>
		/// <returns>返回被成功移除的域的数量，不包括被忽略的域。</returns>
		// Token: 0x060016F7 RID: 5879 RVA: 0x00075CB5 File Offset: 0x00073EB5
		public OperateResult<int> DeleteHashKey(string key, string[] fields)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("HDEL", key, fields));
		}

		/// <summary>
		/// 查看哈希表 key 中，给定域 field 是否存在。如果哈希表含有给定域，返回 1 。
		/// 如果哈希表不含有给定域，或 key 不存在，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="field">域</param>
		/// <returns>如果哈希表含有给定域，返回 1 。如果哈希表不含有给定域，或 key 不存在，返回 0 。</returns>
		// Token: 0x060016F8 RID: 5880 RVA: 0x00075CC9 File Offset: 0x00073EC9
		public OperateResult<int> ExistsHashKey(string key, string field)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"HEXISTS",
				key,
				field
			});
		}

		/// <summary>
		/// 返回哈希表 key 中给定域 field 的值。当给定域不存在或是给定 key 不存在时，返回 nil 
		/// </summary>
		/// <param name="key">关键值</param>
		/// <param name="field">域</param>
		/// <returns>
		/// 给定域的值。
		/// 当给定域不存在或是给定 key 不存在时，返回 nil 。
		/// </returns>
		// Token: 0x060016F9 RID: 5881 RVA: 0x00075CE7 File Offset: 0x00073EE7
		public OperateResult<string> ReadHashKey(string key, string field)
		{
			return this.OperateStringFromServer(new string[]
			{
				"HGET",
				key,
				field
			});
		}

		/// <summary>
		/// 返回哈希表 key 中，所有的域和值。在返回值里，紧跟每个域名(field name)之后是域的值(value)，所以返回值的长度是哈希表大小的两倍。
		/// </summary>
		/// <param name="key">关键值</param>
		/// <returns>
		/// 以列表形式返回哈希表的域和域的值。
		/// 若 key 不存在，返回空列表。
		/// </returns>
		// Token: 0x060016FA RID: 5882 RVA: 0x00075D05 File Offset: 0x00073F05
		public OperateResult<string[]> ReadHashKeyAll(string key)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"HGETALL",
				key
			});
		}

		/// <summary>
		/// 为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。
		/// 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="field">域</param>
		/// <param name="value">增量值</param>
		/// <returns>返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。</returns>
		// Token: 0x060016FB RID: 5883 RVA: 0x00075D1F File Offset: 0x00073F1F
		public OperateResult<long> IncrementHashKey(string key, string field, long value)
		{
			return this.OperateLongNumberFromServer(new string[]
			{
				"HINCRBY",
				key,
				field,
				value.ToString()
			});
		}

		/// <summary>
		/// 为哈希表 key 中的域 field 的值加上增量 increment 。增量也可以为负数，相当于对给定域进行减法操作。
		/// 如果 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="field">域</param>
		/// <param name="value">增量值</param>
		/// <returns>返回执行 HINCRBY 命令之后，哈希表 key 中域 field 的值。</returns>
		// Token: 0x060016FC RID: 5884 RVA: 0x00075D47 File Offset: 0x00073F47
		public OperateResult<string> IncrementHashKey(string key, string field, float value)
		{
			return this.OperateStringFromServer(new string[]
			{
				"HINCRBYFLOAT",
				key,
				field,
				value.ToString()
			});
		}

		/// <summary>
		/// 返回哈希表 key 中的所有域。当 key 不存在时，返回一个空表。
		/// </summary>
		/// <param name="key">关键值</param>
		/// <returns>
		/// 一个包含哈希表中所有域的表。
		/// 当 key 不存在时，返回一个空表。
		/// </returns>
		// Token: 0x060016FD RID: 5885 RVA: 0x00075D6F File Offset: 0x00073F6F
		public OperateResult<string[]> ReadHashKeys(string key)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"HKEYS",
				key
			});
		}

		/// <summary>
		/// 返回哈希表 key 中域的数量。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <returns>哈希表中域的数量。当 key 不存在时，返回 0 。</returns>
		// Token: 0x060016FE RID: 5886 RVA: 0x00075D89 File Offset: 0x00073F89
		public OperateResult<int> ReadHashKeyLength(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"HLEN",
				key
			});
		}

		/// <summary>
		/// 返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。
		/// 因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
		/// </summary>
		/// <param name="key">关键值</param>
		/// <param name="fields">指定的域</param>
		/// <returns>
		/// 一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。
		/// </returns>
		// Token: 0x060016FF RID: 5887 RVA: 0x00075DA3 File Offset: 0x00073FA3
		public OperateResult<string[]> ReadHashKey(string key, string[] fields)
		{
			return this.OperateStringsFromServer(SoftBasic.SpliceStringArray("HMGET", key, fields));
		}

		/// <summary>
		/// 将哈希表 key 中的域 field 的值设为 value 。
		/// 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
		/// 如果域 field 已经存在于哈希表中，旧值将被覆盖。
		/// 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
		/// 如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="field">域</param>
		/// <param name="value">数据值</param>
		/// <returns>
		/// 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1 。
		/// 如果哈希表中域 field 已经存在且旧值已被新值覆盖，返回 0 。
		/// </returns>
		// Token: 0x06001700 RID: 5888 RVA: 0x00075DB7 File Offset: 0x00073FB7
		public OperateResult<int> WriteHashKey(string key, string field, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"HSET",
				key,
				field,
				value
			});
		}

		/// <summary>
		/// 同时将多个 field-value (域-值)对设置到哈希表 key 中。
		/// 此命令会覆盖哈希表中已存在的域。
		/// 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="fields">域</param>
		/// <param name="values">数据值</param>
		/// <returns>
		/// 如果命令执行成功，返回 OK 。
		/// 当 key 不是哈希表(hash)类型时，返回一个错误
		/// </returns>
		// Token: 0x06001701 RID: 5889 RVA: 0x00075DDC File Offset: 0x00073FDC
		public OperateResult WriteHashKey(string key, string[] fields, string[] values)
		{
			bool flag = fields == null;
			if (flag)
			{
				throw new ArgumentNullException("fields");
			}
			bool flag2 = values == null;
			if (flag2)
			{
				throw new ArgumentNullException("values");
			}
			bool flag3 = fields.Length != values.Length;
			if (flag3)
			{
				throw new ArgumentException("Two arguement not same length");
			}
			List<string> list = new List<string>();
			list.Add("HMSET");
			list.Add(key);
			for (int i = 0; i < fields.Length; i++)
			{
				list.Add(fields[i]);
				list.Add(values[i]);
			}
			return this.OperateStatusFromServer(list.ToArray());
		}

		/// <summary>
		/// 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。若域 field 已经存在，该操作无效。
		/// 设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。
		/// </summary>
		/// <param name="key">关键字</param>
		/// <param name="field">域</param>
		/// <param name="value">数据值</param>
		/// <returns>设置成功，返回 1 。如果给定域已经存在且没有操作被执行，返回 0 。</returns>
		// Token: 0x06001702 RID: 5890 RVA: 0x00075E86 File Offset: 0x00074086
		public OperateResult<int> WriteHashKeyNx(string key, string field, string value)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"HSETNX",
				key,
				field,
				value
			});
		}

		/// <summary>
		/// 返回哈希表 key 中所有域的值。当 key 不存在时，返回一个空表。
		/// </summary>
		/// <param name="key">关键值</param>
		/// <returns>
		/// 返回哈希表 key 中所有域的值。
		/// 当 key 不存在时，返回一个空表。
		/// </returns>
		// Token: 0x06001703 RID: 5891 RVA: 0x00075EA8 File Offset: 0x000740A8
		public OperateResult<string[]> ReadHashValues(string key)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"HVALS",
				key
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteHashKey(System.String,System.String)" />
		// Token: 0x06001704 RID: 5892 RVA: 0x00075EC4 File Offset: 0x000740C4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteHashKeyAsync(string key, string field)
		{
			RedisClient.<DeleteHashKeyAsync>d__122 <DeleteHashKeyAsync>d__ = new RedisClient.<DeleteHashKeyAsync>d__122();
			<DeleteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteHashKeyAsync>d__.<>4__this = this;
			<DeleteHashKeyAsync>d__.key = key;
			<DeleteHashKeyAsync>d__.field = field;
			<DeleteHashKeyAsync>d__.<>1__state = -1;
			<DeleteHashKeyAsync>d__.<>t__builder.Start<RedisClient.<DeleteHashKeyAsync>d__122>(ref <DeleteHashKeyAsync>d__);
			return <DeleteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DeleteHashKey(System.String,System.String[])" />
		// Token: 0x06001705 RID: 5893 RVA: 0x00075F18 File Offset: 0x00074118
		[DebuggerStepThrough]
		public Task<OperateResult<int>> DeleteHashKeyAsync(string key, string[] fields)
		{
			RedisClient.<DeleteHashKeyAsync>d__123 <DeleteHashKeyAsync>d__ = new RedisClient.<DeleteHashKeyAsync>d__123();
			<DeleteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<DeleteHashKeyAsync>d__.<>4__this = this;
			<DeleteHashKeyAsync>d__.key = key;
			<DeleteHashKeyAsync>d__.fields = fields;
			<DeleteHashKeyAsync>d__.<>1__state = -1;
			<DeleteHashKeyAsync>d__.<>t__builder.Start<RedisClient.<DeleteHashKeyAsync>d__123>(ref <DeleteHashKeyAsync>d__);
			return <DeleteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ExistsHashKey(System.String,System.String)" />
		// Token: 0x06001706 RID: 5894 RVA: 0x00075F6C File Offset: 0x0007416C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ExistsHashKeyAsync(string key, string field)
		{
			RedisClient.<ExistsHashKeyAsync>d__124 <ExistsHashKeyAsync>d__ = new RedisClient.<ExistsHashKeyAsync>d__124();
			<ExistsHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ExistsHashKeyAsync>d__.<>4__this = this;
			<ExistsHashKeyAsync>d__.key = key;
			<ExistsHashKeyAsync>d__.field = field;
			<ExistsHashKeyAsync>d__.<>1__state = -1;
			<ExistsHashKeyAsync>d__.<>t__builder.Start<RedisClient.<ExistsHashKeyAsync>d__124>(ref <ExistsHashKeyAsync>d__);
			return <ExistsHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKey(System.String,System.String)" />
		// Token: 0x06001707 RID: 5895 RVA: 0x00075FC0 File Offset: 0x000741C0
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadHashKeyAsync(string key, string field)
		{
			RedisClient.<ReadHashKeyAsync>d__125 <ReadHashKeyAsync>d__ = new RedisClient.<ReadHashKeyAsync>d__125();
			<ReadHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadHashKeyAsync>d__.<>4__this = this;
			<ReadHashKeyAsync>d__.key = key;
			<ReadHashKeyAsync>d__.field = field;
			<ReadHashKeyAsync>d__.<>1__state = -1;
			<ReadHashKeyAsync>d__.<>t__builder.Start<RedisClient.<ReadHashKeyAsync>d__125>(ref <ReadHashKeyAsync>d__);
			return <ReadHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKeyAll(System.String)" />
		// Token: 0x06001708 RID: 5896 RVA: 0x00076014 File Offset: 0x00074214
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashKeyAllAsync(string key)
		{
			RedisClient.<ReadHashKeyAllAsync>d__126 <ReadHashKeyAllAsync>d__ = new RedisClient.<ReadHashKeyAllAsync>d__126();
			<ReadHashKeyAllAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashKeyAllAsync>d__.<>4__this = this;
			<ReadHashKeyAllAsync>d__.key = key;
			<ReadHashKeyAllAsync>d__.<>1__state = -1;
			<ReadHashKeyAllAsync>d__.<>t__builder.Start<RedisClient.<ReadHashKeyAllAsync>d__126>(ref <ReadHashKeyAllAsync>d__);
			return <ReadHashKeyAllAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementHashKey(System.String,System.String,System.Int64)" />
		// Token: 0x06001709 RID: 5897 RVA: 0x00076060 File Offset: 0x00074260
		[DebuggerStepThrough]
		public Task<OperateResult<long>> IncrementHashKeyAsync(string key, string field, long value)
		{
			RedisClient.<IncrementHashKeyAsync>d__127 <IncrementHashKeyAsync>d__ = new RedisClient.<IncrementHashKeyAsync>d__127();
			<IncrementHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<IncrementHashKeyAsync>d__.<>4__this = this;
			<IncrementHashKeyAsync>d__.key = key;
			<IncrementHashKeyAsync>d__.field = field;
			<IncrementHashKeyAsync>d__.value = value;
			<IncrementHashKeyAsync>d__.<>1__state = -1;
			<IncrementHashKeyAsync>d__.<>t__builder.Start<RedisClient.<IncrementHashKeyAsync>d__127>(ref <IncrementHashKeyAsync>d__);
			return <IncrementHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.IncrementHashKey(System.String,System.String,System.Single)" />
		// Token: 0x0600170A RID: 5898 RVA: 0x000760BC File Offset: 0x000742BC
		[DebuggerStepThrough]
		public Task<OperateResult<string>> IncrementHashKeyAsync(string key, string field, float value)
		{
			RedisClient.<IncrementHashKeyAsync>d__128 <IncrementHashKeyAsync>d__ = new RedisClient.<IncrementHashKeyAsync>d__128();
			<IncrementHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<IncrementHashKeyAsync>d__.<>4__this = this;
			<IncrementHashKeyAsync>d__.key = key;
			<IncrementHashKeyAsync>d__.field = field;
			<IncrementHashKeyAsync>d__.value = value;
			<IncrementHashKeyAsync>d__.<>1__state = -1;
			<IncrementHashKeyAsync>d__.<>t__builder.Start<RedisClient.<IncrementHashKeyAsync>d__128>(ref <IncrementHashKeyAsync>d__);
			return <IncrementHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKeys(System.String)" />
		// Token: 0x0600170B RID: 5899 RVA: 0x00076118 File Offset: 0x00074318
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashKeysAsync(string key)
		{
			RedisClient.<ReadHashKeysAsync>d__129 <ReadHashKeysAsync>d__ = new RedisClient.<ReadHashKeysAsync>d__129();
			<ReadHashKeysAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashKeysAsync>d__.<>4__this = this;
			<ReadHashKeysAsync>d__.key = key;
			<ReadHashKeysAsync>d__.<>1__state = -1;
			<ReadHashKeysAsync>d__.<>t__builder.Start<RedisClient.<ReadHashKeysAsync>d__129>(ref <ReadHashKeysAsync>d__);
			return <ReadHashKeysAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKeyLength(System.String)" />
		// Token: 0x0600170C RID: 5900 RVA: 0x00076164 File Offset: 0x00074364
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadHashKeyLengthAsync(string key)
		{
			RedisClient.<ReadHashKeyLengthAsync>d__130 <ReadHashKeyLengthAsync>d__ = new RedisClient.<ReadHashKeyLengthAsync>d__130();
			<ReadHashKeyLengthAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadHashKeyLengthAsync>d__.<>4__this = this;
			<ReadHashKeyLengthAsync>d__.key = key;
			<ReadHashKeyLengthAsync>d__.<>1__state = -1;
			<ReadHashKeyLengthAsync>d__.<>t__builder.Start<RedisClient.<ReadHashKeyLengthAsync>d__130>(ref <ReadHashKeyLengthAsync>d__);
			return <ReadHashKeyLengthAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashKey(System.String,System.String[])" />
		// Token: 0x0600170D RID: 5901 RVA: 0x000761B0 File Offset: 0x000743B0
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashKeyAsync(string key, string[] fields)
		{
			RedisClient.<ReadHashKeyAsync>d__131 <ReadHashKeyAsync>d__ = new RedisClient.<ReadHashKeyAsync>d__131();
			<ReadHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashKeyAsync>d__.<>4__this = this;
			<ReadHashKeyAsync>d__.key = key;
			<ReadHashKeyAsync>d__.fields = fields;
			<ReadHashKeyAsync>d__.<>1__state = -1;
			<ReadHashKeyAsync>d__.<>t__builder.Start<RedisClient.<ReadHashKeyAsync>d__131>(ref <ReadHashKeyAsync>d__);
			return <ReadHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteHashKey(System.String,System.String,System.String)" />
		// Token: 0x0600170E RID: 5902 RVA: 0x00076204 File Offset: 0x00074404
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteHashKeyAsync(string key, string field, string value)
		{
			RedisClient.<WriteHashKeyAsync>d__132 <WriteHashKeyAsync>d__ = new RedisClient.<WriteHashKeyAsync>d__132();
			<WriteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteHashKeyAsync>d__.<>4__this = this;
			<WriteHashKeyAsync>d__.key = key;
			<WriteHashKeyAsync>d__.field = field;
			<WriteHashKeyAsync>d__.value = value;
			<WriteHashKeyAsync>d__.<>1__state = -1;
			<WriteHashKeyAsync>d__.<>t__builder.Start<RedisClient.<WriteHashKeyAsync>d__132>(ref <WriteHashKeyAsync>d__);
			return <WriteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteHashKey(System.String,System.String[],System.String[])" />
		// Token: 0x0600170F RID: 5903 RVA: 0x00076260 File Offset: 0x00074460
		[DebuggerStepThrough]
		public Task<OperateResult> WriteHashKeyAsync(string key, string[] fields, string[] values)
		{
			RedisClient.<WriteHashKeyAsync>d__133 <WriteHashKeyAsync>d__ = new RedisClient.<WriteHashKeyAsync>d__133();
			<WriteHashKeyAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteHashKeyAsync>d__.<>4__this = this;
			<WriteHashKeyAsync>d__.key = key;
			<WriteHashKeyAsync>d__.fields = fields;
			<WriteHashKeyAsync>d__.values = values;
			<WriteHashKeyAsync>d__.<>1__state = -1;
			<WriteHashKeyAsync>d__.<>t__builder.Start<RedisClient.<WriteHashKeyAsync>d__133>(ref <WriteHashKeyAsync>d__);
			return <WriteHashKeyAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.WriteHashKeyNx(System.String,System.String,System.String)" />
		// Token: 0x06001710 RID: 5904 RVA: 0x000762BC File Offset: 0x000744BC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> WriteHashKeyNxAsync(string key, string field, string value)
		{
			RedisClient.<WriteHashKeyNxAsync>d__134 <WriteHashKeyNxAsync>d__ = new RedisClient.<WriteHashKeyNxAsync>d__134();
			<WriteHashKeyNxAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<WriteHashKeyNxAsync>d__.<>4__this = this;
			<WriteHashKeyNxAsync>d__.key = key;
			<WriteHashKeyNxAsync>d__.field = field;
			<WriteHashKeyNxAsync>d__.value = value;
			<WriteHashKeyNxAsync>d__.<>1__state = -1;
			<WriteHashKeyNxAsync>d__.<>t__builder.Start<RedisClient.<WriteHashKeyNxAsync>d__134>(ref <WriteHashKeyNxAsync>d__);
			return <WriteHashKeyNxAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadHashValues(System.String)" />
		// Token: 0x06001711 RID: 5905 RVA: 0x00076318 File Offset: 0x00074518
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ReadHashValuesAsync(string key)
		{
			RedisClient.<ReadHashValuesAsync>d__135 <ReadHashValuesAsync>d__ = new RedisClient.<ReadHashValuesAsync>d__135();
			<ReadHashValuesAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ReadHashValuesAsync>d__.<>4__this = this;
			<ReadHashValuesAsync>d__.key = key;
			<ReadHashValuesAsync>d__.<>1__state = -1;
			<ReadHashValuesAsync>d__.<>t__builder.Start<RedisClient.<ReadHashValuesAsync>d__135>(ref <ReadHashValuesAsync>d__);
			return <ReadHashValuesAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 将一个member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。假如 key 不存在，则创建一个只包含 member 元素作成员的集合。当 key 不是集合类型时，返回一个错误。
		/// </summary>
		/// <param name="key">关键字信息</param>
		/// <param name="member">等待添加的元素</param>
		/// <returns>被添加到集合中的新元素的数量，不包括被忽略的元素。</returns>
		// Token: 0x06001712 RID: 5906 RVA: 0x00076363 File Offset: 0x00074563
		public OperateResult<int> SetAdd(string key, string member)
		{
			return this.SetAdd(key, new string[]
			{
				member
			});
		}

		/// <summary>
		/// 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。假如 key 不存在，则创建一个只包含 member 元素作成员的集合。当 key 不是集合类型时，返回一个错误。
		/// </summary>
		/// <param name="key">关键字信息</param>
		/// <param name="members">等待添加的元素</param>
		/// <returns>被添加到集合中的新元素的数量，不包括被忽略的元素。</returns>
		// Token: 0x06001713 RID: 5907 RVA: 0x00076376 File Offset: 0x00074576
		public OperateResult<int> SetAdd(string key, string[] members)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("SADD", key, members));
		}

		/// <summary>
		/// 返回集合 key 的基数(集合中元素的数量)。当 key 不存在时，返回 0 。
		/// </summary>
		/// <param name="key">集合 key 的名称</param>
		/// <returns>集合的基数。</returns>
		// Token: 0x06001714 RID: 5908 RVA: 0x0007638A File Offset: 0x0007458A
		public OperateResult<int> SetCard(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"SCARD",
				key
			});
		}

		/// <summary>
		/// 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="diffKey">集合关键字</param>
		/// <returns>交集成员的列表。</returns>
		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiff(System.String,System.String[])" />
		// Token: 0x06001715 RID: 5909 RVA: 0x000763A4 File Offset: 0x000745A4
		public OperateResult<string[]> SetDiff(string key, string diffKey)
		{
			return this.SetDiff(key, new string[]
			{
				diffKey
			});
		}

		/// <summary>
		/// 返回一个集合的全部成员，该集合是所有给定集合之间的差集。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="diffKeys">集合关键字</param>
		/// <returns>交集成员的列表。</returns>
		// Token: 0x06001716 RID: 5910 RVA: 0x000763B7 File Offset: 0x000745B7
		public OperateResult<string[]> SetDiff(string key, string[] diffKeys)
		{
			return this.OperateStringsFromServer(SoftBasic.SpliceStringArray("SDIFF", key, diffKeys));
		}

		/// <summary>
		/// 这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 集合已经存在，则将其覆盖。destination 可以是 key 本身。
		/// </summary>
		/// <param name="destination">目标集合</param>
		/// <param name="key">等待操作的集合</param>
		/// <param name="diffKey">运算的集合</param>
		/// <returns>结果集中的元素数量。</returns>
		// Token: 0x06001717 RID: 5911 RVA: 0x000763CB File Offset: 0x000745CB
		public OperateResult<int> SetDiffStore(string destination, string key, string diffKey)
		{
			return this.SetDiffStore(destination, key, new string[]
			{
				diffKey
			});
		}

		/// <summary>
		/// 这个命令的作用和 SDIFF 类似，但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 集合已经存在，则将其覆盖。destination 可以是 key 本身。
		/// </summary>
		/// <param name="destination">目标集合</param>
		/// <param name="key">等待操作的集合</param>
		/// <param name="diffKeys">运算的集合</param>
		/// <returns>结果集中的元素数量。</returns>
		// Token: 0x06001718 RID: 5912 RVA: 0x000763DF File Offset: 0x000745DF
		public OperateResult<int> SetDiffStore(string destination, string key, string[] diffKeys)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("SDIFFSTORE", destination, key, diffKeys));
		}

		/// <summary>
		/// 返回一个集合的全部成员，该集合是所有给定集合的交集。不存在的 key 被视为空集。当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="interKey">运算的集合</param>
		/// <returns>交集成员的列表。</returns>
		// Token: 0x06001719 RID: 5913 RVA: 0x000763F4 File Offset: 0x000745F4
		public OperateResult<string[]> SetInter(string key, string interKey)
		{
			return this.SetInter(key, new string[]
			{
				interKey
			});
		}

		/// <summary>
		/// 返回一个集合的全部成员，该集合是所有给定集合的交集。不存在的 key 被视为空集。当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="interKeys">运算的集合</param>
		/// <returns>交集成员的列表。</returns>
		// Token: 0x0600171A RID: 5914 RVA: 0x00076407 File Offset: 0x00074607
		public OperateResult<string[]> SetInter(string key, string[] interKeys)
		{
			return this.OperateStringsFromServer(SoftBasic.SpliceStringArray("SINTER", key, interKeys));
		}

		/// <summary>
		/// 这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 集合已经存在，则将其覆盖。destination 可以是 key 本身。
		/// </summary>
		/// <param name="destination">目标集合</param>
		/// <param name="key">等待操作的集合</param>
		/// <param name="interKey">运算的集合</param>
		/// <returns>结果集中的成员数量。</returns>
		// Token: 0x0600171B RID: 5915 RVA: 0x0007641B File Offset: 0x0007461B
		public OperateResult<int> SetInterStore(string destination, string key, string interKey)
		{
			return this.SetInterStore(destination, key, new string[]
			{
				interKey
			});
		}

		/// <summary>
		/// 这个命令类似于 SINTER 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 集合已经存在，则将其覆盖。destination 可以是 key 本身。
		/// </summary>
		/// <param name="destination">目标集合</param>
		/// <param name="key">等待操作的集合</param>
		/// <param name="interKeys">运算的集合</param>
		/// <returns>结果集中的成员数量。</returns>
		// Token: 0x0600171C RID: 5916 RVA: 0x0007642F File Offset: 0x0007462F
		public OperateResult<int> SetInterStore(string destination, string key, string[] interKeys)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("SINTERSTORE", destination, key, interKeys));
		}

		/// <summary>
		/// 判断 member 元素是否集合 key 的成员。如果 member 元素是集合的成员，返回 1 。如果 member 元素不是集合的成员，或 key 不存在，返回 0 。
		/// </summary>
		/// <param name="key">集合key</param>
		/// <param name="member">元素</param>
		/// <returns>如果 member 元素是集合的成员，返回 1 。如果 member 元素不是集合的成员，或 key 不存在，返回 0 。</returns>
		// Token: 0x0600171D RID: 5917 RVA: 0x00076444 File Offset: 0x00074644
		public OperateResult<int> SetIsMember(string key, string member)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"SISMEMBER",
				key,
				member
			});
		}

		/// <summary>
		/// 返回集合 key 中的所有成员。不存在的 key 被视为空集合。
		/// </summary>
		/// <param name="key">集合key</param>
		/// <returns>集合中的所有成员。</returns>
		// Token: 0x0600171E RID: 5918 RVA: 0x00076462 File Offset: 0x00074662
		public OperateResult<string[]> SetMembers(string key)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"SMEMBERS",
				key
			});
		}

		/// <summary>
		/// 将 member 元素从 source 集合移动到 destination 集合。如果 source 集合不存在或不包含指定的 member 元素，则 SMOVE 命令不执行任何操作，仅返回 0 。
		/// 否则， member 元素从 source 集合中被移除，并添加到 destination 集合中去。当 destination 集合已经包含 member 元素时， SMOVE 命令只是简单地将 source 集合中的 member 元素删除。
		/// 当 source 或 destination 不是集合类型时，返回一个错误。
		/// </summary>
		/// <param name="source">原集合</param>
		/// <param name="destination">目标集合</param>
		/// <param name="member">元素</param>
		/// <returns>如果 member 元素被成功移除，返回 1 。如果 member 元素不是 source 集合的成员，并且没有任何操作对 destination 集合执行，那么返回 0 。</returns>
		// Token: 0x0600171F RID: 5919 RVA: 0x0007647C File Offset: 0x0007467C
		public OperateResult<int> SetMove(string source, string destination, string member)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"SMOVE",
				source,
				destination,
				member
			});
		}

		/// <summary>
		/// 移除并返回集合中的一个随机元素。如果只想获取一个随机元素，但不想该元素从集合中被移除的话，可以使用 SRANDMEMBER 命令。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <returns>被移除的随机元素。当 key 不存在或 key 是空集时，返回 nil 。</returns>
		// Token: 0x06001720 RID: 5920 RVA: 0x0007649E File Offset: 0x0007469E
		public OperateResult<string> SetPop(string key)
		{
			return this.OperateStringFromServer(new string[]
			{
				"SPOP",
				key
			});
		}

		/// <summary>
		/// 那么返回集合中的一个随机元素。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <returns>返回一个元素；如果集合为空，返回 nil 。</returns>
		// Token: 0x06001721 RID: 5921 RVA: 0x000764B8 File Offset: 0x000746B8
		public OperateResult<string> SetRandomMember(string key)
		{
			return this.OperateStringFromServer(new string[]
			{
				"SRANDMEMBER",
				key
			});
		}

		/// <summary>
		/// 返回集合中的多个随机元素。<br />
		/// 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。<br />
		/// 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="count">元素个数</param>
		/// <returns>返回一个数组；如果集合为空，返回空数组。</returns>
		// Token: 0x06001722 RID: 5922 RVA: 0x000764D2 File Offset: 0x000746D2
		public OperateResult<string[]> SetRandomMember(string key, int count)
		{
			return this.OperateStringsFromServer(new string[]
			{
				"SRANDMEMBER",
				key,
				count.ToString()
			});
		}

		/// <summary>
		/// 移除集合 key 中的一个元素，不存在的 member 元素会被忽略。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="member">等待移除的元素</param>
		/// <returns>被成功移除的元素的数量，不包括被忽略的元素。</returns>
		// Token: 0x06001723 RID: 5923 RVA: 0x000764F6 File Offset: 0x000746F6
		public OperateResult<int> SetRemove(string key, string member)
		{
			return this.SetRemove(key, new string[]
			{
				member
			});
		}

		/// <summary>
		/// 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="members">等待移除的元素</param>
		/// <returns>被成功移除的元素的数量，不包括被忽略的元素。</returns>
		// Token: 0x06001724 RID: 5924 RVA: 0x00076509 File Offset: 0x00074709
		public OperateResult<int> SetRemove(string key, string[] members)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("SREM", key, members));
		}

		/// <summary>
		/// 返回一个集合的全部成员，该集合是所有给定集合的并集。不存在的 key 被视为空集。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="unionKey">并集的集合</param>
		/// <returns>并集成员的列表。</returns>
		// Token: 0x06001725 RID: 5925 RVA: 0x0007651D File Offset: 0x0007471D
		public OperateResult<string[]> SetUnion(string key, string unionKey)
		{
			return this.SetUnion(key, new string[]
			{
				unionKey
			});
		}

		/// <summary>
		/// 返回一个或多个集合的全部成员，该集合是所有给定集合的并集。不存在的 key 被视为空集。
		/// </summary>
		/// <param name="key">集合关键字</param>
		/// <param name="unionKeys">并集的集合</param>
		/// <returns>并集成员的列表。</returns>
		// Token: 0x06001726 RID: 5926 RVA: 0x00076530 File Offset: 0x00074730
		public OperateResult<string[]> SetUnion(string key, string[] unionKeys)
		{
			return this.OperateStringsFromServer(SoftBasic.SpliceStringArray("SUNION", key, unionKeys));
		}

		/// <summary>
		/// 这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 已经存在，则将其覆盖。destination 可以是 key 本身。
		/// </summary>
		/// <param name="destination">存储的目标集合</param>
		/// <param name="key">集合关键字</param>
		/// <param name="unionKey">并集的集合</param>
		/// <returns>结果集中的元素数量。</returns>
		// Token: 0x06001727 RID: 5927 RVA: 0x00076544 File Offset: 0x00074744
		public OperateResult<int> SetUnionStore(string destination, string key, string unionKey)
		{
			return this.SetUnionStore(destination, key, unionKey);
		}

		/// <summary>
		/// 这个命令类似于 SUNION 命令，但它将结果保存到 destination 集合，而不是简单地返回结果集。如果 destination 已经存在，则将其覆盖。destination 可以是 key 本身。
		/// </summary>
		/// <param name="destination">存储的目标集合</param>
		/// <param name="key">集合关键字</param>
		/// <param name="unionKeys">并集的集合</param>
		/// <returns>结果集中的元素数量。</returns>
		// Token: 0x06001728 RID: 5928 RVA: 0x0007654F File Offset: 0x0007474F
		public OperateResult<int> SetUnionStore(string destination, string key, string[] unionKeys)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("SUNIONSTORE", destination, key, unionKeys));
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetAdd(System.String,System.String)" />
		// Token: 0x06001729 RID: 5929 RVA: 0x00076564 File Offset: 0x00074764
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetAddAsync(string key, string member)
		{
			RedisClient.<SetAddAsync>d__159 <SetAddAsync>d__ = new RedisClient.<SetAddAsync>d__159();
			<SetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetAddAsync>d__.<>4__this = this;
			<SetAddAsync>d__.key = key;
			<SetAddAsync>d__.member = member;
			<SetAddAsync>d__.<>1__state = -1;
			<SetAddAsync>d__.<>t__builder.Start<RedisClient.<SetAddAsync>d__159>(ref <SetAddAsync>d__);
			return <SetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetAdd(System.String,System.String[])" />
		// Token: 0x0600172A RID: 5930 RVA: 0x000765B8 File Offset: 0x000747B8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetAddAsync(string key, string[] members)
		{
			RedisClient.<SetAddAsync>d__160 <SetAddAsync>d__ = new RedisClient.<SetAddAsync>d__160();
			<SetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetAddAsync>d__.<>4__this = this;
			<SetAddAsync>d__.key = key;
			<SetAddAsync>d__.members = members;
			<SetAddAsync>d__.<>1__state = -1;
			<SetAddAsync>d__.<>t__builder.Start<RedisClient.<SetAddAsync>d__160>(ref <SetAddAsync>d__);
			return <SetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetCard(System.String)" />
		// Token: 0x0600172B RID: 5931 RVA: 0x0007660C File Offset: 0x0007480C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetCardAsync(string key)
		{
			RedisClient.<SetCardAsync>d__161 <SetCardAsync>d__ = new RedisClient.<SetCardAsync>d__161();
			<SetCardAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetCardAsync>d__.<>4__this = this;
			<SetCardAsync>d__.key = key;
			<SetCardAsync>d__.<>1__state = -1;
			<SetCardAsync>d__.<>t__builder.Start<RedisClient.<SetCardAsync>d__161>(ref <SetCardAsync>d__);
			return <SetCardAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiff(System.String,System.String)" />
		// Token: 0x0600172C RID: 5932 RVA: 0x00076658 File Offset: 0x00074858
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetDiffAsync(string key, string diffKey)
		{
			RedisClient.<SetDiffAsync>d__162 <SetDiffAsync>d__ = new RedisClient.<SetDiffAsync>d__162();
			<SetDiffAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetDiffAsync>d__.<>4__this = this;
			<SetDiffAsync>d__.key = key;
			<SetDiffAsync>d__.diffKey = diffKey;
			<SetDiffAsync>d__.<>1__state = -1;
			<SetDiffAsync>d__.<>t__builder.Start<RedisClient.<SetDiffAsync>d__162>(ref <SetDiffAsync>d__);
			return <SetDiffAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiff(System.String,System.String[])" />
		// Token: 0x0600172D RID: 5933 RVA: 0x000766AC File Offset: 0x000748AC
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetDiffAsync(string key, string[] diffKeys)
		{
			RedisClient.<SetDiffAsync>d__163 <SetDiffAsync>d__ = new RedisClient.<SetDiffAsync>d__163();
			<SetDiffAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetDiffAsync>d__.<>4__this = this;
			<SetDiffAsync>d__.key = key;
			<SetDiffAsync>d__.diffKeys = diffKeys;
			<SetDiffAsync>d__.<>1__state = -1;
			<SetDiffAsync>d__.<>t__builder.Start<RedisClient.<SetDiffAsync>d__163>(ref <SetDiffAsync>d__);
			return <SetDiffAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiffStore(System.String,System.String,System.String)" />
		// Token: 0x0600172E RID: 5934 RVA: 0x00076700 File Offset: 0x00074900
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetDiffStoreAsync(string destination, string key, string diffKey)
		{
			RedisClient.<SetDiffStoreAsync>d__164 <SetDiffStoreAsync>d__ = new RedisClient.<SetDiffStoreAsync>d__164();
			<SetDiffStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetDiffStoreAsync>d__.<>4__this = this;
			<SetDiffStoreAsync>d__.destination = destination;
			<SetDiffStoreAsync>d__.key = key;
			<SetDiffStoreAsync>d__.diffKey = diffKey;
			<SetDiffStoreAsync>d__.<>1__state = -1;
			<SetDiffStoreAsync>d__.<>t__builder.Start<RedisClient.<SetDiffStoreAsync>d__164>(ref <SetDiffStoreAsync>d__);
			return <SetDiffStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetDiffStore(System.String,System.String,System.String[])" />
		// Token: 0x0600172F RID: 5935 RVA: 0x0007675C File Offset: 0x0007495C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetDiffStoreAsync(string destination, string key, string[] diffKeys)
		{
			RedisClient.<SetDiffStoreAsync>d__165 <SetDiffStoreAsync>d__ = new RedisClient.<SetDiffStoreAsync>d__165();
			<SetDiffStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetDiffStoreAsync>d__.<>4__this = this;
			<SetDiffStoreAsync>d__.destination = destination;
			<SetDiffStoreAsync>d__.key = key;
			<SetDiffStoreAsync>d__.diffKeys = diffKeys;
			<SetDiffStoreAsync>d__.<>1__state = -1;
			<SetDiffStoreAsync>d__.<>t__builder.Start<RedisClient.<SetDiffStoreAsync>d__165>(ref <SetDiffStoreAsync>d__);
			return <SetDiffStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInter(System.String,System.String)" />
		// Token: 0x06001730 RID: 5936 RVA: 0x000767B8 File Offset: 0x000749B8
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetInterAsync(string key, string interKey)
		{
			RedisClient.<SetInterAsync>d__166 <SetInterAsync>d__ = new RedisClient.<SetInterAsync>d__166();
			<SetInterAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetInterAsync>d__.<>4__this = this;
			<SetInterAsync>d__.key = key;
			<SetInterAsync>d__.interKey = interKey;
			<SetInterAsync>d__.<>1__state = -1;
			<SetInterAsync>d__.<>t__builder.Start<RedisClient.<SetInterAsync>d__166>(ref <SetInterAsync>d__);
			return <SetInterAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInter(System.String,System.String[])" />
		// Token: 0x06001731 RID: 5937 RVA: 0x0007680C File Offset: 0x00074A0C
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetInterAsync(string key, string[] interKeys)
		{
			RedisClient.<SetInterAsync>d__167 <SetInterAsync>d__ = new RedisClient.<SetInterAsync>d__167();
			<SetInterAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetInterAsync>d__.<>4__this = this;
			<SetInterAsync>d__.key = key;
			<SetInterAsync>d__.interKeys = interKeys;
			<SetInterAsync>d__.<>1__state = -1;
			<SetInterAsync>d__.<>t__builder.Start<RedisClient.<SetInterAsync>d__167>(ref <SetInterAsync>d__);
			return <SetInterAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInterStore(System.String,System.String,System.String)" />
		// Token: 0x06001732 RID: 5938 RVA: 0x00076860 File Offset: 0x00074A60
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetInterStoreAsync(string destination, string key, string interKey)
		{
			RedisClient.<SetInterStoreAsync>d__168 <SetInterStoreAsync>d__ = new RedisClient.<SetInterStoreAsync>d__168();
			<SetInterStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetInterStoreAsync>d__.<>4__this = this;
			<SetInterStoreAsync>d__.destination = destination;
			<SetInterStoreAsync>d__.key = key;
			<SetInterStoreAsync>d__.interKey = interKey;
			<SetInterStoreAsync>d__.<>1__state = -1;
			<SetInterStoreAsync>d__.<>t__builder.Start<RedisClient.<SetInterStoreAsync>d__168>(ref <SetInterStoreAsync>d__);
			return <SetInterStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetInterStore(System.String,System.String,System.String[])" />
		// Token: 0x06001733 RID: 5939 RVA: 0x000768BC File Offset: 0x00074ABC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetInterStoreAsync(string destination, string key, string[] interKeys)
		{
			RedisClient.<SetInterStoreAsync>d__169 <SetInterStoreAsync>d__ = new RedisClient.<SetInterStoreAsync>d__169();
			<SetInterStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetInterStoreAsync>d__.<>4__this = this;
			<SetInterStoreAsync>d__.destination = destination;
			<SetInterStoreAsync>d__.key = key;
			<SetInterStoreAsync>d__.interKeys = interKeys;
			<SetInterStoreAsync>d__.<>1__state = -1;
			<SetInterStoreAsync>d__.<>t__builder.Start<RedisClient.<SetInterStoreAsync>d__169>(ref <SetInterStoreAsync>d__);
			return <SetInterStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetIsMember(System.String,System.String)" />
		// Token: 0x06001734 RID: 5940 RVA: 0x00076918 File Offset: 0x00074B18
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetIsMemberAsync(string key, string member)
		{
			RedisClient.<SetIsMemberAsync>d__170 <SetIsMemberAsync>d__ = new RedisClient.<SetIsMemberAsync>d__170();
			<SetIsMemberAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetIsMemberAsync>d__.<>4__this = this;
			<SetIsMemberAsync>d__.key = key;
			<SetIsMemberAsync>d__.member = member;
			<SetIsMemberAsync>d__.<>1__state = -1;
			<SetIsMemberAsync>d__.<>t__builder.Start<RedisClient.<SetIsMemberAsync>d__170>(ref <SetIsMemberAsync>d__);
			return <SetIsMemberAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetMembers(System.String)" />
		// Token: 0x06001735 RID: 5941 RVA: 0x0007696C File Offset: 0x00074B6C
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetMembersAsync(string key)
		{
			RedisClient.<SetMembersAsync>d__171 <SetMembersAsync>d__ = new RedisClient.<SetMembersAsync>d__171();
			<SetMembersAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetMembersAsync>d__.<>4__this = this;
			<SetMembersAsync>d__.key = key;
			<SetMembersAsync>d__.<>1__state = -1;
			<SetMembersAsync>d__.<>t__builder.Start<RedisClient.<SetMembersAsync>d__171>(ref <SetMembersAsync>d__);
			return <SetMembersAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetMove(System.String,System.String,System.String)" />
		// Token: 0x06001736 RID: 5942 RVA: 0x000769B8 File Offset: 0x00074BB8
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetMoveAsync(string source, string destination, string member)
		{
			RedisClient.<SetMoveAsync>d__172 <SetMoveAsync>d__ = new RedisClient.<SetMoveAsync>d__172();
			<SetMoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetMoveAsync>d__.<>4__this = this;
			<SetMoveAsync>d__.source = source;
			<SetMoveAsync>d__.destination = destination;
			<SetMoveAsync>d__.member = member;
			<SetMoveAsync>d__.<>1__state = -1;
			<SetMoveAsync>d__.<>t__builder.Start<RedisClient.<SetMoveAsync>d__172>(ref <SetMoveAsync>d__);
			return <SetMoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetPop(System.String)" />
		// Token: 0x06001737 RID: 5943 RVA: 0x00076A14 File Offset: 0x00074C14
		[DebuggerStepThrough]
		public Task<OperateResult<string>> SetPopAsync(string key)
		{
			RedisClient.<SetPopAsync>d__173 <SetPopAsync>d__ = new RedisClient.<SetPopAsync>d__173();
			<SetPopAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<SetPopAsync>d__.<>4__this = this;
			<SetPopAsync>d__.key = key;
			<SetPopAsync>d__.<>1__state = -1;
			<SetPopAsync>d__.<>t__builder.Start<RedisClient.<SetPopAsync>d__173>(ref <SetPopAsync>d__);
			return <SetPopAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRandomMember(System.String)" />
		// Token: 0x06001738 RID: 5944 RVA: 0x00076A60 File Offset: 0x00074C60
		[DebuggerStepThrough]
		public Task<OperateResult<string>> SetRandomMemberAsync(string key)
		{
			RedisClient.<SetRandomMemberAsync>d__174 <SetRandomMemberAsync>d__ = new RedisClient.<SetRandomMemberAsync>d__174();
			<SetRandomMemberAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<SetRandomMemberAsync>d__.<>4__this = this;
			<SetRandomMemberAsync>d__.key = key;
			<SetRandomMemberAsync>d__.<>1__state = -1;
			<SetRandomMemberAsync>d__.<>t__builder.Start<RedisClient.<SetRandomMemberAsync>d__174>(ref <SetRandomMemberAsync>d__);
			return <SetRandomMemberAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRandomMember(System.String,System.Int32)" />
		// Token: 0x06001739 RID: 5945 RVA: 0x00076AAC File Offset: 0x00074CAC
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetRandomMemberAsync(string key, int count)
		{
			RedisClient.<SetRandomMemberAsync>d__175 <SetRandomMemberAsync>d__ = new RedisClient.<SetRandomMemberAsync>d__175();
			<SetRandomMemberAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetRandomMemberAsync>d__.<>4__this = this;
			<SetRandomMemberAsync>d__.key = key;
			<SetRandomMemberAsync>d__.count = count;
			<SetRandomMemberAsync>d__.<>1__state = -1;
			<SetRandomMemberAsync>d__.<>t__builder.Start<RedisClient.<SetRandomMemberAsync>d__175>(ref <SetRandomMemberAsync>d__);
			return <SetRandomMemberAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRemove(System.String,System.String)" />
		// Token: 0x0600173A RID: 5946 RVA: 0x00076B00 File Offset: 0x00074D00
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetRemoveAsync(string key, string member)
		{
			RedisClient.<SetRemoveAsync>d__176 <SetRemoveAsync>d__ = new RedisClient.<SetRemoveAsync>d__176();
			<SetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetRemoveAsync>d__.<>4__this = this;
			<SetRemoveAsync>d__.key = key;
			<SetRemoveAsync>d__.member = member;
			<SetRemoveAsync>d__.<>1__state = -1;
			<SetRemoveAsync>d__.<>t__builder.Start<RedisClient.<SetRemoveAsync>d__176>(ref <SetRemoveAsync>d__);
			return <SetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetRemove(System.String,System.String[])" />
		// Token: 0x0600173B RID: 5947 RVA: 0x00076B54 File Offset: 0x00074D54
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetRemoveAsync(string key, string[] members)
		{
			RedisClient.<SetRemoveAsync>d__177 <SetRemoveAsync>d__ = new RedisClient.<SetRemoveAsync>d__177();
			<SetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetRemoveAsync>d__.<>4__this = this;
			<SetRemoveAsync>d__.key = key;
			<SetRemoveAsync>d__.members = members;
			<SetRemoveAsync>d__.<>1__state = -1;
			<SetRemoveAsync>d__.<>t__builder.Start<RedisClient.<SetRemoveAsync>d__177>(ref <SetRemoveAsync>d__);
			return <SetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnion(System.String,System.String)" />
		// Token: 0x0600173C RID: 5948 RVA: 0x00076BA8 File Offset: 0x00074DA8
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetUnionAsync(string key, string unionKey)
		{
			RedisClient.<SetUnionAsync>d__178 <SetUnionAsync>d__ = new RedisClient.<SetUnionAsync>d__178();
			<SetUnionAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetUnionAsync>d__.<>4__this = this;
			<SetUnionAsync>d__.key = key;
			<SetUnionAsync>d__.unionKey = unionKey;
			<SetUnionAsync>d__.<>1__state = -1;
			<SetUnionAsync>d__.<>t__builder.Start<RedisClient.<SetUnionAsync>d__178>(ref <SetUnionAsync>d__);
			return <SetUnionAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnion(System.String,System.String[])" />
		// Token: 0x0600173D RID: 5949 RVA: 0x00076BFC File Offset: 0x00074DFC
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> SetUnionAsync(string key, string[] unionKeys)
		{
			RedisClient.<SetUnionAsync>d__179 <SetUnionAsync>d__ = new RedisClient.<SetUnionAsync>d__179();
			<SetUnionAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<SetUnionAsync>d__.<>4__this = this;
			<SetUnionAsync>d__.key = key;
			<SetUnionAsync>d__.unionKeys = unionKeys;
			<SetUnionAsync>d__.<>1__state = -1;
			<SetUnionAsync>d__.<>t__builder.Start<RedisClient.<SetUnionAsync>d__179>(ref <SetUnionAsync>d__);
			return <SetUnionAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnionStore(System.String,System.String,System.String)" />
		// Token: 0x0600173E RID: 5950 RVA: 0x00076C50 File Offset: 0x00074E50
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetUnionStoreAsync(string destination, string key, string unionKey)
		{
			RedisClient.<SetUnionStoreAsync>d__180 <SetUnionStoreAsync>d__ = new RedisClient.<SetUnionStoreAsync>d__180();
			<SetUnionStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetUnionStoreAsync>d__.<>4__this = this;
			<SetUnionStoreAsync>d__.destination = destination;
			<SetUnionStoreAsync>d__.key = key;
			<SetUnionStoreAsync>d__.unionKey = unionKey;
			<SetUnionStoreAsync>d__.<>1__state = -1;
			<SetUnionStoreAsync>d__.<>t__builder.Start<RedisClient.<SetUnionStoreAsync>d__180>(ref <SetUnionStoreAsync>d__);
			return <SetUnionStoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SetUnionStore(System.String,System.String,System.String[])" />
		// Token: 0x0600173F RID: 5951 RVA: 0x00076CAC File Offset: 0x00074EAC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> SetUnionStoreAsync(string destination, string key, string[] unionKeys)
		{
			RedisClient.<SetUnionStoreAsync>d__181 <SetUnionStoreAsync>d__ = new RedisClient.<SetUnionStoreAsync>d__181();
			<SetUnionStoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<SetUnionStoreAsync>d__.<>4__this = this;
			<SetUnionStoreAsync>d__.destination = destination;
			<SetUnionStoreAsync>d__.key = key;
			<SetUnionStoreAsync>d__.unionKeys = unionKeys;
			<SetUnionStoreAsync>d__.<>1__state = -1;
			<SetUnionStoreAsync>d__.<>t__builder.Start<RedisClient.<SetUnionStoreAsync>d__181>(ref <SetUnionStoreAsync>d__);
			return <SetUnionStoreAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 将一个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
		/// score 值可以是整数值或双精度浮点数。<br />
		/// 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。当 key 存在但不是有序集类型时，返回一个错误。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="member">有序集合的元素</param>
		/// <param name="score">每个元素的得分</param>
		/// <returns>被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。</returns>
		// Token: 0x06001740 RID: 5952 RVA: 0x00076D05 File Offset: 0x00074F05
		public OperateResult<int> ZSetAdd(string key, string member, double score)
		{
			return this.ZSetAdd(key, new string[]
			{
				member
			}, new double[]
			{
				score
			});
		}

		/// <summary>
		/// 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。
		/// score 值可以是整数值或双精度浮点数。<br />
		/// 如果 key 不存在，则创建一个空的有序集并执行 ZADD 操作。当 key 存在但不是有序集类型时，返回一个错误。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="members">有序集合的元素</param>
		/// <param name="scores">每个元素的得分</param>
		/// <returns>被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员。</returns>
		// Token: 0x06001741 RID: 5953 RVA: 0x00076D24 File Offset: 0x00074F24
		public OperateResult<int> ZSetAdd(string key, string[] members, double[] scores)
		{
			bool flag = members.Length != scores.Length;
			if (flag)
			{
				throw new Exception(StringResources.Language.TwoParametersLengthIsNotSame);
			}
			List<string> list = new List<string>();
			list.Add("ZADD");
			list.Add(key);
			for (int i = 0; i < members.Length; i++)
			{
				list.Add(scores[i].ToString());
				list.Add(members[i]);
			}
			return this.OperateNumberFromServer(list.ToArray());
		}

		/// <summary>
		/// 返回有序集 key 的基数。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <returns>当 key 存在且是有序集类型时，返回有序集的基数。当 key 不存在时，返回 0 。</returns>
		// Token: 0x06001742 RID: 5954 RVA: 0x00076DAE File Offset: 0x00074FAE
		public OperateResult<int> ZSetCard(string key)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"ZCARD",
				key
			});
		}

		/// <summary>
		/// 返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="min">最小值，包含</param>
		/// <param name="max">最大值，包含</param>
		/// <returns>score 值在 min 和 max 之间的成员的数量。</returns>
		// Token: 0x06001743 RID: 5955 RVA: 0x00076DC8 File Offset: 0x00074FC8
		public OperateResult<int> ZSetCount(string key, double min, double max)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"ZCOUNT",
				key,
				min.ToString(),
				max.ToString()
			});
		}

		/// <summary>
		/// 为有序集 key 的成员 member 的 score 值加上增量 increment 。可以通过传递一个负数值 increment ，让 score 减去相应的值，比如 ZINCRBY key -5 member ，就是让 member 的 score 值减去 5 。
		/// 当 key 不存在，或 member 不是 key 的成员时， ZINCRBY key increment member 等同于 ZADD key increment member 。当 key 不是有序集类型时，返回一个错误。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="member">成员名称</param>
		/// <param name="increment">增量数据，可以为负数</param>
		/// <returns>member 成员的新 score 值，以字符串形式表示。</returns>
		// Token: 0x06001744 RID: 5956 RVA: 0x00076DF6 File Offset: 0x00074FF6
		public OperateResult<string> ZSetIncreaseBy(string key, string member, double increment)
		{
			return this.OperateStringFromServer(new string[]
			{
				"ZINCRBY",
				key,
				increment.ToString(),
				member
			});
		}

		/// <summary>
		/// 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递增(从小到大)来排序。具有相同 score 值的成员按字典序来排列。
		/// 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
		/// </summary>
		/// <remarks>
		/// 超出范围的下标并不会引起错误。比如说，当 start 的值比有序集的最大下标还要大，或是 start &gt; stop 时， ZRANGE 命令只是简单地返回一个空列表。另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。
		/// 可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。
		/// </remarks>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="start">起始的下标</param>
		/// <param name="stop">结束的下标</param>
		/// <param name="withScore">是否带有 score 返回</param>
		/// <returns>指定区间内，根据参数 withScore 来决定是否带 score 值的有序集成员的列表。</returns>
		// Token: 0x06001745 RID: 5957 RVA: 0x00076E20 File Offset: 0x00075020
		public OperateResult<string[]> ZSetRange(string key, int start, int stop, bool withScore = false)
		{
			OperateResult<string[]> result;
			if (withScore)
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZRANGE",
					key,
					start.ToString(),
					stop.ToString(),
					"WITHSCORES"
				});
			}
			else
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZRANGE",
					key,
					start.ToString(),
					stop.ToString()
				});
			}
			return result;
		}

		/// <summary>
		/// 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
		/// min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
		/// 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 "(" 符号来使用可选的开区间 (小于或大于)。"(5"代表不包含5
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="min">最小值，可以为-inf，代表最高，如果为5，代表大于等于5，如果是(5，代表大于5</param>
		/// <param name="max">最大值，可以为+inf，代表最低，如果为10，代表小于等于5，如果是(10，代表小于10</param>
		/// <param name="withScore">是否带有 score 返回</param>
		/// <returns>指定区间内，带有 score 值(根据参数 withScore 来决定)的有序集成员的列表。</returns>
		// Token: 0x06001746 RID: 5958 RVA: 0x00076E9C File Offset: 0x0007509C
		public OperateResult<string[]> ZSetRangeByScore(string key, string min, string max, bool withScore = false)
		{
			OperateResult<string[]> result;
			if (withScore)
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZRANGEBYSCORE",
					key,
					min,
					max,
					"WITHSCORES"
				});
			}
			else
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZRANGEBYSCORE",
					key,
					min,
					max
				});
			}
			return result;
		}

		/// <summary>
		/// 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。排名以 0 为底，也就是说， score 值最小的成员排名为 0 。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="member">成员 member 的名称</param>
		/// <returns>如果 member 是有序集 key 的成员，返回 member 的排名。如果 member 不是有序集 key 的成员，返回 nil 。</returns>
		// Token: 0x06001747 RID: 5959 RVA: 0x00076EFF File Offset: 0x000750FF
		public OperateResult<int> ZSetRank(string key, string member)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"ZRANK",
				key,
				member
			});
		}

		/// <summary>
		/// 移除有序集 key 中的指定成员，不存在的成员将被忽略。当 key 存在但不是有序集类型时，返回一个错误。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="member">等待被移除的成员</param>
		/// <returns>被成功移除的成员的数量，不包括被忽略的成员。</returns>
		// Token: 0x06001748 RID: 5960 RVA: 0x00076F1D File Offset: 0x0007511D
		public OperateResult<int> ZSetRemove(string key, string member)
		{
			return this.ZSetRemove(key, new string[]
			{
				member
			});
		}

		/// <summary>
		/// 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略。当 key 存在但不是有序集类型时，返回一个错误。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="members">等待被移除的成员</param>
		/// <returns>被成功移除的成员的数量，不包括被忽略的成员。</returns>
		// Token: 0x06001749 RID: 5961 RVA: 0x00076F30 File Offset: 0x00075130
		public OperateResult<int> ZSetRemove(string key, string[] members)
		{
			return this.OperateNumberFromServer(SoftBasic.SpliceStringArray("ZREM", key, members));
		}

		/// <summary>
		/// 移除有序集 key 中，指定排名(rank)区间内的所有成员。区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。
		/// 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
		/// </summary>
		/// <param name="key">有序集合的关键</param>
		/// <param name="start">开始的下标</param>
		/// <param name="stop">结束的下标</param>
		/// <returns>被移除成员的数量。</returns>
		// Token: 0x0600174A RID: 5962 RVA: 0x00076F44 File Offset: 0x00075144
		public OperateResult<int> ZSetRemoveRangeByRank(string key, int start, int stop)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"ZREMRANGEBYRANK",
				key,
				start.ToString(),
				stop.ToString()
			});
		}

		/// <summary>
		/// 移除有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。
		/// min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
		/// 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 "(" 符号来使用可选的开区间 (小于或大于)。例如"(5"代表不包括5
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="min">最小值，可以为-inf，代表最低，如果为5，代表大于等于5，如果是(5，代表大于5</param>
		/// <param name="max">最大值，可以为+inf，代表最低，如果为10，代表小于等于5，如果是(10，代表小于10</param>
		/// <returns>被移除成员的数量。</returns>
		// Token: 0x0600174B RID: 5963 RVA: 0x00076F72 File Offset: 0x00075172
		public OperateResult<int> ZSetRemoveRangeByScore(string key, string min, string max)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"ZREMRANGEBYSCORE",
				key,
				min,
				max
			});
		}

		/// <summary>
		/// 返回有序集 key 中，指定区间内的成员。其中成员的位置按 score 值递减(从大到小)来排列。具有相同 score 值的成员按字典序来排列。
		/// 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。你也可以使用负数下标，以 -1 表示最后一个成员， -2 表示倒数第二个成员，以此类推。
		/// </summary>
		/// <remarks>
		/// 超出范围的下标并不会引起错误。比如说，当 start 的值比有序集的最大下标还要大，或是 start &gt; stop 时， ZRANGE 命令只是简单地返回一个空列表。另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。
		/// 可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, ..., valueN,scoreN 的格式表示。客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。
		/// </remarks>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="start">起始的下标</param>
		/// <param name="stop">结束的下标</param>
		/// <param name="withScore">是否带有 score 返回</param>
		/// <returns>指定区间内，根据参数 withScore 来决定是否带 score 值的有序集成员的列表。</returns>
		// Token: 0x0600174C RID: 5964 RVA: 0x00076F94 File Offset: 0x00075194
		public OperateResult<string[]> ZSetReverseRange(string key, int start, int stop, bool withScore = false)
		{
			OperateResult<string[]> result;
			if (withScore)
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZREVRANGE",
					key,
					start.ToString(),
					stop.ToString(),
					"WITHSCORES"
				});
			}
			else
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZREVRANGE",
					key,
					start.ToString(),
					stop.ToString()
				});
			}
			return result;
		}

		/// <summary>
		/// 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。序集成员按 score 值递减(从大到小)的次序排列。
		/// min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 ZRANGEBYSCORE 这类命令。
		/// 默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)。(5代表不包含5
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="max">最大值，可以为+inf，代表最高，如果为10，代表小于等于5，如果是(10，代表小于10</param>
		/// <param name="min">最小值，可以为-inf，代表最低，如果为5，代表大于等于5，如果是(5，代表大于5</param>
		/// <param name="withScore">是否带有 score 返回</param>
		/// <returns>指定区间内，带有 score 值(根据参数 withScore 来决定)的有序集成员的列表。</returns>
		// Token: 0x0600174D RID: 5965 RVA: 0x00077010 File Offset: 0x00075210
		public OperateResult<string[]> ZSetReverseRangeByScore(string key, string max, string min, bool withScore = false)
		{
			OperateResult<string[]> result;
			if (withScore)
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZREVRANGEBYSCORE",
					key,
					max,
					min,
					"WITHSCORES"
				});
			}
			else
			{
				result = this.OperateStringsFromServer(new string[]
				{
					"ZREVRANGEBYSCORE",
					key,
					max,
					min
				});
			}
			return result;
		}

		/// <summary>
		/// 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递减(从大到小)排序。排名以 0 为底，也就是说，score 值最大的成员排名为 0 。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="member">成员 member 的名称</param>
		/// <returns>如果 member 是有序集 key 的成员，返回 member 的排名。如果 member 不是有序集 key 的成员，返回 nil 。</returns>
		// Token: 0x0600174E RID: 5966 RVA: 0x00077073 File Offset: 0x00075273
		public OperateResult<int> ZSetReverseRank(string key, string member)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"ZREVRANK",
				key,
				member
			});
		}

		/// <summary>
		/// 返回有序集 key 中，成员 member 的 score 值。如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil 。
		/// </summary>
		/// <param name="key">有序集合的关键字</param>
		/// <param name="member">成员的名称</param>
		/// <returns>member 成员的 score 值，以字符串形式表示。</returns>
		// Token: 0x0600174F RID: 5967 RVA: 0x00077091 File Offset: 0x00075291
		public OperateResult<string> ZSetScore(string key, string member)
		{
			return this.OperateStringFromServer(new string[]
			{
				"ZSCORE",
				key,
				member
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetAdd(System.String,System.String,System.Double)" />
		// Token: 0x06001750 RID: 5968 RVA: 0x000770B0 File Offset: 0x000752B0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetAddAsync(string key, string member, double score)
		{
			RedisClient.<ZSetAddAsync>d__198 <ZSetAddAsync>d__ = new RedisClient.<ZSetAddAsync>d__198();
			<ZSetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetAddAsync>d__.<>4__this = this;
			<ZSetAddAsync>d__.key = key;
			<ZSetAddAsync>d__.member = member;
			<ZSetAddAsync>d__.score = score;
			<ZSetAddAsync>d__.<>1__state = -1;
			<ZSetAddAsync>d__.<>t__builder.Start<RedisClient.<ZSetAddAsync>d__198>(ref <ZSetAddAsync>d__);
			return <ZSetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetAdd(System.String,System.String[],System.Double[])" />
		// Token: 0x06001751 RID: 5969 RVA: 0x0007710C File Offset: 0x0007530C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetAddAsync(string key, string[] members, double[] scores)
		{
			RedisClient.<ZSetAddAsync>d__199 <ZSetAddAsync>d__ = new RedisClient.<ZSetAddAsync>d__199();
			<ZSetAddAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetAddAsync>d__.<>4__this = this;
			<ZSetAddAsync>d__.key = key;
			<ZSetAddAsync>d__.members = members;
			<ZSetAddAsync>d__.scores = scores;
			<ZSetAddAsync>d__.<>1__state = -1;
			<ZSetAddAsync>d__.<>t__builder.Start<RedisClient.<ZSetAddAsync>d__199>(ref <ZSetAddAsync>d__);
			return <ZSetAddAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetCard(System.String)" />
		// Token: 0x06001752 RID: 5970 RVA: 0x00077168 File Offset: 0x00075368
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetCardAsync(string key)
		{
			RedisClient.<ZSetCardAsync>d__200 <ZSetCardAsync>d__ = new RedisClient.<ZSetCardAsync>d__200();
			<ZSetCardAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetCardAsync>d__.<>4__this = this;
			<ZSetCardAsync>d__.key = key;
			<ZSetCardAsync>d__.<>1__state = -1;
			<ZSetCardAsync>d__.<>t__builder.Start<RedisClient.<ZSetCardAsync>d__200>(ref <ZSetCardAsync>d__);
			return <ZSetCardAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetCount(System.String,System.Double,System.Double)" />
		// Token: 0x06001753 RID: 5971 RVA: 0x000771B4 File Offset: 0x000753B4
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetCountAsync(string key, double min, double max)
		{
			RedisClient.<ZSetCountAsync>d__201 <ZSetCountAsync>d__ = new RedisClient.<ZSetCountAsync>d__201();
			<ZSetCountAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetCountAsync>d__.<>4__this = this;
			<ZSetCountAsync>d__.key = key;
			<ZSetCountAsync>d__.min = min;
			<ZSetCountAsync>d__.max = max;
			<ZSetCountAsync>d__.<>1__state = -1;
			<ZSetCountAsync>d__.<>t__builder.Start<RedisClient.<ZSetCountAsync>d__201>(ref <ZSetCountAsync>d__);
			return <ZSetCountAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetIncreaseBy(System.String,System.String,System.Double)" />
		// Token: 0x06001754 RID: 5972 RVA: 0x00077210 File Offset: 0x00075410
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ZSetIncreaseByAsync(string key, string member, double increment)
		{
			RedisClient.<ZSetIncreaseByAsync>d__202 <ZSetIncreaseByAsync>d__ = new RedisClient.<ZSetIncreaseByAsync>d__202();
			<ZSetIncreaseByAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ZSetIncreaseByAsync>d__.<>4__this = this;
			<ZSetIncreaseByAsync>d__.key = key;
			<ZSetIncreaseByAsync>d__.member = member;
			<ZSetIncreaseByAsync>d__.increment = increment;
			<ZSetIncreaseByAsync>d__.<>1__state = -1;
			<ZSetIncreaseByAsync>d__.<>t__builder.Start<RedisClient.<ZSetIncreaseByAsync>d__202>(ref <ZSetIncreaseByAsync>d__);
			return <ZSetIncreaseByAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRange(System.String,System.Int32,System.Int32,System.Boolean)" />
		// Token: 0x06001755 RID: 5973 RVA: 0x0007726C File Offset: 0x0007546C
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetRangeAsync(string key, int start, int stop, bool withScore = false)
		{
			RedisClient.<ZSetRangeAsync>d__203 <ZSetRangeAsync>d__ = new RedisClient.<ZSetRangeAsync>d__203();
			<ZSetRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetRangeAsync>d__.<>4__this = this;
			<ZSetRangeAsync>d__.key = key;
			<ZSetRangeAsync>d__.start = start;
			<ZSetRangeAsync>d__.stop = stop;
			<ZSetRangeAsync>d__.withScore = withScore;
			<ZSetRangeAsync>d__.<>1__state = -1;
			<ZSetRangeAsync>d__.<>t__builder.Start<RedisClient.<ZSetRangeAsync>d__203>(ref <ZSetRangeAsync>d__);
			return <ZSetRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRangeByScore(System.String,System.String,System.String,System.Boolean)" />
		// Token: 0x06001756 RID: 5974 RVA: 0x000772D0 File Offset: 0x000754D0
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetRangeByScoreAsync(string key, string min, string max, bool withScore = false)
		{
			RedisClient.<ZSetRangeByScoreAsync>d__204 <ZSetRangeByScoreAsync>d__ = new RedisClient.<ZSetRangeByScoreAsync>d__204();
			<ZSetRangeByScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetRangeByScoreAsync>d__.<>4__this = this;
			<ZSetRangeByScoreAsync>d__.key = key;
			<ZSetRangeByScoreAsync>d__.min = min;
			<ZSetRangeByScoreAsync>d__.max = max;
			<ZSetRangeByScoreAsync>d__.withScore = withScore;
			<ZSetRangeByScoreAsync>d__.<>1__state = -1;
			<ZSetRangeByScoreAsync>d__.<>t__builder.Start<RedisClient.<ZSetRangeByScoreAsync>d__204>(ref <ZSetRangeByScoreAsync>d__);
			return <ZSetRangeByScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRank(System.String,System.String)" />
		// Token: 0x06001757 RID: 5975 RVA: 0x00077334 File Offset: 0x00075534
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRankAsync(string key, string member)
		{
			RedisClient.<ZSetRankAsync>d__205 <ZSetRankAsync>d__ = new RedisClient.<ZSetRankAsync>d__205();
			<ZSetRankAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRankAsync>d__.<>4__this = this;
			<ZSetRankAsync>d__.key = key;
			<ZSetRankAsync>d__.member = member;
			<ZSetRankAsync>d__.<>1__state = -1;
			<ZSetRankAsync>d__.<>t__builder.Start<RedisClient.<ZSetRankAsync>d__205>(ref <ZSetRankAsync>d__);
			return <ZSetRankAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemove(System.String,System.String)" />
		// Token: 0x06001758 RID: 5976 RVA: 0x00077388 File Offset: 0x00075588
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveAsync(string key, string member)
		{
			RedisClient.<ZSetRemoveAsync>d__206 <ZSetRemoveAsync>d__ = new RedisClient.<ZSetRemoveAsync>d__206();
			<ZSetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveAsync>d__.<>4__this = this;
			<ZSetRemoveAsync>d__.key = key;
			<ZSetRemoveAsync>d__.member = member;
			<ZSetRemoveAsync>d__.<>1__state = -1;
			<ZSetRemoveAsync>d__.<>t__builder.Start<RedisClient.<ZSetRemoveAsync>d__206>(ref <ZSetRemoveAsync>d__);
			return <ZSetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemove(System.String,System.String[])" />
		// Token: 0x06001759 RID: 5977 RVA: 0x000773DC File Offset: 0x000755DC
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveAsync(string key, string[] members)
		{
			RedisClient.<ZSetRemoveAsync>d__207 <ZSetRemoveAsync>d__ = new RedisClient.<ZSetRemoveAsync>d__207();
			<ZSetRemoveAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveAsync>d__.<>4__this = this;
			<ZSetRemoveAsync>d__.key = key;
			<ZSetRemoveAsync>d__.members = members;
			<ZSetRemoveAsync>d__.<>1__state = -1;
			<ZSetRemoveAsync>d__.<>t__builder.Start<RedisClient.<ZSetRemoveAsync>d__207>(ref <ZSetRemoveAsync>d__);
			return <ZSetRemoveAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemoveRangeByRank(System.String,System.Int32,System.Int32)" />
		// Token: 0x0600175A RID: 5978 RVA: 0x00077430 File Offset: 0x00075630
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveRangeByRankAsync(string key, int start, int stop)
		{
			RedisClient.<ZSetRemoveRangeByRankAsync>d__208 <ZSetRemoveRangeByRankAsync>d__ = new RedisClient.<ZSetRemoveRangeByRankAsync>d__208();
			<ZSetRemoveRangeByRankAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveRangeByRankAsync>d__.<>4__this = this;
			<ZSetRemoveRangeByRankAsync>d__.key = key;
			<ZSetRemoveRangeByRankAsync>d__.start = start;
			<ZSetRemoveRangeByRankAsync>d__.stop = stop;
			<ZSetRemoveRangeByRankAsync>d__.<>1__state = -1;
			<ZSetRemoveRangeByRankAsync>d__.<>t__builder.Start<RedisClient.<ZSetRemoveRangeByRankAsync>d__208>(ref <ZSetRemoveRangeByRankAsync>d__);
			return <ZSetRemoveRangeByRankAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetRemoveRangeByScore(System.String,System.String,System.String)" />
		// Token: 0x0600175B RID: 5979 RVA: 0x0007748C File Offset: 0x0007568C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetRemoveRangeByScoreAsync(string key, string min, string max)
		{
			RedisClient.<ZSetRemoveRangeByScoreAsync>d__209 <ZSetRemoveRangeByScoreAsync>d__ = new RedisClient.<ZSetRemoveRangeByScoreAsync>d__209();
			<ZSetRemoveRangeByScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetRemoveRangeByScoreAsync>d__.<>4__this = this;
			<ZSetRemoveRangeByScoreAsync>d__.key = key;
			<ZSetRemoveRangeByScoreAsync>d__.min = min;
			<ZSetRemoveRangeByScoreAsync>d__.max = max;
			<ZSetRemoveRangeByScoreAsync>d__.<>1__state = -1;
			<ZSetRemoveRangeByScoreAsync>d__.<>t__builder.Start<RedisClient.<ZSetRemoveRangeByScoreAsync>d__209>(ref <ZSetRemoveRangeByScoreAsync>d__);
			return <ZSetRemoveRangeByScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetReverseRange(System.String,System.Int32,System.Int32,System.Boolean)" />
		// Token: 0x0600175C RID: 5980 RVA: 0x000774E8 File Offset: 0x000756E8
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetReverseRangeAsync(string key, int start, int stop, bool withScore = false)
		{
			RedisClient.<ZSetReverseRangeAsync>d__210 <ZSetReverseRangeAsync>d__ = new RedisClient.<ZSetReverseRangeAsync>d__210();
			<ZSetReverseRangeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetReverseRangeAsync>d__.<>4__this = this;
			<ZSetReverseRangeAsync>d__.key = key;
			<ZSetReverseRangeAsync>d__.start = start;
			<ZSetReverseRangeAsync>d__.stop = stop;
			<ZSetReverseRangeAsync>d__.withScore = withScore;
			<ZSetReverseRangeAsync>d__.<>1__state = -1;
			<ZSetReverseRangeAsync>d__.<>t__builder.Start<RedisClient.<ZSetReverseRangeAsync>d__210>(ref <ZSetReverseRangeAsync>d__);
			return <ZSetReverseRangeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetReverseRangeByScore(System.String,System.String,System.String,System.Boolean)" />
		// Token: 0x0600175D RID: 5981 RVA: 0x0007754C File Offset: 0x0007574C
		[DebuggerStepThrough]
		public Task<OperateResult<string[]>> ZSetReverseRangeByScoreAsync(string key, string max, string min, bool withScore = false)
		{
			RedisClient.<ZSetReverseRangeByScoreAsync>d__211 <ZSetReverseRangeByScoreAsync>d__ = new RedisClient.<ZSetReverseRangeByScoreAsync>d__211();
			<ZSetReverseRangeByScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string[]>>.Create();
			<ZSetReverseRangeByScoreAsync>d__.<>4__this = this;
			<ZSetReverseRangeByScoreAsync>d__.key = key;
			<ZSetReverseRangeByScoreAsync>d__.max = max;
			<ZSetReverseRangeByScoreAsync>d__.min = min;
			<ZSetReverseRangeByScoreAsync>d__.withScore = withScore;
			<ZSetReverseRangeByScoreAsync>d__.<>1__state = -1;
			<ZSetReverseRangeByScoreAsync>d__.<>t__builder.Start<RedisClient.<ZSetReverseRangeByScoreAsync>d__211>(ref <ZSetReverseRangeByScoreAsync>d__);
			return <ZSetReverseRangeByScoreAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetReverseRank(System.String,System.String)" />
		// Token: 0x0600175E RID: 5982 RVA: 0x000775B0 File Offset: 0x000757B0
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ZSetReverseRankAsync(string key, string member)
		{
			RedisClient.<ZSetReverseRankAsync>d__212 <ZSetReverseRankAsync>d__ = new RedisClient.<ZSetReverseRankAsync>d__212();
			<ZSetReverseRankAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ZSetReverseRankAsync>d__.<>4__this = this;
			<ZSetReverseRankAsync>d__.key = key;
			<ZSetReverseRankAsync>d__.member = member;
			<ZSetReverseRankAsync>d__.<>1__state = -1;
			<ZSetReverseRankAsync>d__.<>t__builder.Start<RedisClient.<ZSetReverseRankAsync>d__212>(ref <ZSetReverseRankAsync>d__);
			return <ZSetReverseRankAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ZSetScore(System.String,System.String)" />
		// Token: 0x0600175F RID: 5983 RVA: 0x00077604 File Offset: 0x00075804
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ZSetScoreAsync(string key, string member)
		{
			RedisClient.<ZSetScoreAsync>d__213 <ZSetScoreAsync>d__ = new RedisClient.<ZSetScoreAsync>d__213();
			<ZSetScoreAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ZSetScoreAsync>d__.<>4__this = this;
			<ZSetScoreAsync>d__.key = key;
			<ZSetScoreAsync>d__.member = member;
			<ZSetScoreAsync>d__.<>1__state = -1;
			<ZSetScoreAsync>d__.<>t__builder.Start<RedisClient.<ZSetScoreAsync>d__213>(ref <ZSetScoreAsync>d__);
			return <ZSetScoreAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 从设备里读取支持Hsl特性的数据内容，
		/// 该特性为<see cref="T:HslCommunication.Reflection.HslRedisKeyAttribute" />，<see cref="T:HslCommunication.Reflection.HslRedisListItemAttribute" />，
		/// <see cref="T:HslCommunication.Reflection.HslRedisListAttribute" />，<see cref="T:HslCommunication.Reflection.HslRedisHashFieldAttribute" />
		/// 详细参考代码示例的操作说明。
		/// </summary>
		/// <typeparam name="T">自定义的数据类型对象</typeparam>
		/// <returns>包含是否成功的结果对象</returns>
		/// <example>
		/// 我们来说明下这个方法到底是怎么用的，当我们需要读取redis好几个数据的时候，我们很可能写如下的代码：
		/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="Sample1" title="基础的使用" />
		/// 总的来说，当读取的数据种类比较多的时候，读取的关键字比较多的时候，处理起来就比较的麻烦，此处推荐一个全新的写法，为了更好的对比，我们假设实现一种需求
		/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="Sample2" title="同等代码" />
		/// 为此我们只需要实现一个特性类即可。代码如下：(注意，实际是很灵活的，类型都是自动转换的)
		/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="SampleClass" title="数据类" />
		/// 当然了，异步也是一样的，异步的代码就不重复介绍了。
		/// <code lang="cs" source="HslCommunication_Net45.Test\Documentation\Samples\Enthernet\RedisSample.cs" region="Sample3" title="异步示例" />
		/// </example>
		// Token: 0x06001760 RID: 5984 RVA: 0x00077656 File Offset: 0x00075856
		public OperateResult<T> Read<T>() where T : class, new()
		{
			return HslReflectionHelper.Read<T>(this);
		}

		/// <summary>
		/// 从设备里写入支持Hsl特性的数据内容，
		/// 该特性为<see cref="T:HslCommunication.Reflection.HslRedisKeyAttribute" /> ，<see cref="T:HslCommunication.Reflection.HslRedisHashFieldAttribute" />
		/// 需要注意的是写入并不支持<see cref="T:HslCommunication.Reflection.HslRedisListAttribute" />，<see cref="T:HslCommunication.Reflection.HslRedisListItemAttribute" />特性，详细参考代码示例的操作说明。
		/// </summary>
		/// <typeparam name="T">自定义的数据类型对象</typeparam>
		/// <param name="data">等待写入的数据参数</param>
		/// <returns>包含是否成功的结果对象</returns>
		/// <example>
		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Read``1" path="example" />
		/// </example>
		// Token: 0x06001761 RID: 5985 RVA: 0x0007765E File Offset: 0x0007585E
		public OperateResult Write<T>(T data) where T : class, new()
		{
			return HslReflectionHelper.Write<T>(data, this);
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Read``1" />
		// Token: 0x06001762 RID: 5986 RVA: 0x00077668 File Offset: 0x00075868
		[DebuggerStepThrough]
		public Task<OperateResult<T>> ReadAsync<T>() where T : class, new()
		{
			RedisClient.<ReadAsync>d__216<T> <ReadAsync>d__ = new RedisClient.<ReadAsync>d__216<T>();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<RedisClient.<ReadAsync>d__216<T>>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Write``1(``0)" />
		// Token: 0x06001763 RID: 5987 RVA: 0x000776AC File Offset: 0x000758AC
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync<T>(T data) where T : class, new()
		{
			RedisClient.<WriteAsync>d__217<T> <WriteAsync>d__ = new RedisClient.<WriteAsync>d__217<T>();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.data = data;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<RedisClient.<WriteAsync>d__217<T>>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// SAVE 命令执行一个同步保存操作，将当前 Redis 实例的所有数据快照(snapshot)以 RDB 文件的形式保存到硬盘。
		/// </summary>
		/// <returns>保存成功时返回 OK 。</returns>
		// Token: 0x06001764 RID: 5988 RVA: 0x000776F7 File Offset: 0x000758F7
		public OperateResult Save()
		{
			return this.OperateStatusFromServer(new string[]
			{
				"SAVE"
			});
		}

		/// <summary>
		/// 在后台异步(Asynchronously)保存当前数据库的数据到磁盘。
		/// BGSAVE 命令执行之后立即返回 OK ，然后 Redis fork 出一个新子进程，原来的 Redis 进程(父进程)继续处理客户端请求，而子进程则负责将数据保存到磁盘，然后退出。
		/// </summary>
		/// <returns>反馈信息。</returns>
		// Token: 0x06001765 RID: 5989 RVA: 0x0007770D File Offset: 0x0007590D
		public OperateResult SaveAsync()
		{
			return this.OperateStatusFromServer(new string[]
			{
				"BGSAVE"
			});
		}

		/// <summary>
		/// 获取服务器的时间戳信息，可用于本地时间的数据同步问题
		/// </summary>
		/// <returns>带有服务器时间的结果对象</returns>
		// Token: 0x06001766 RID: 5990 RVA: 0x00077724 File Offset: 0x00075924
		public OperateResult<DateTime> ReadServerTime()
		{
			OperateResult<string[]> operateResult = this.OperateStringsFromServer(new string[]
			{
				"TIME"
			});
			bool flag = !operateResult.IsSuccess;
			OperateResult<DateTime> result;
			if (flag)
			{
				result = OperateResult.CreateFailedResult<DateTime>(operateResult);
			}
			else
			{
				long num = long.Parse(operateResult.Content[0]);
				DateTime value = new DateTime(1970, 1, 1, 8, 0, 0).AddSeconds((double)num);
				result = OperateResult.CreateSuccessResult<DateTime>(value);
			}
			return result;
		}

		/// <summary>
		/// 向服务器进行PING的操作，服务器会返回PONG操作
		/// </summary>
		/// <returns>是否成功</returns>
		// Token: 0x06001767 RID: 5991 RVA: 0x00077793 File Offset: 0x00075993
		public OperateResult Ping()
		{
			return this.OperateStatusFromServer(new string[]
			{
				"PING"
			});
		}

		/// <summary>
		/// 返回当前数据库的 key 的数量。
		/// </summary>
		/// <returns>当前数据库的 key 的数量。</returns>
		// Token: 0x06001768 RID: 5992 RVA: 0x000777A9 File Offset: 0x000759A9
		public OperateResult<long> DBSize()
		{
			return this.OperateLongNumberFromServer(new string[]
			{
				"DBSIZE"
			});
		}

		/// <summary>
		/// 清空当前的数据库的key信息
		/// </summary>
		/// <returns>总是返回 OK 。</returns>
		// Token: 0x06001769 RID: 5993 RVA: 0x000777BF File Offset: 0x000759BF
		public OperateResult FlushDB()
		{
			return this.OperateStatusFromServer(new string[]
			{
				"FLUSHDB"
			});
		}

		/// <summary>
		/// 修改Redis的密码信息，如果不需要密码，则传入空字符串即可
		/// </summary>
		/// <param name="password">密码信息</param>
		/// <returns>是否更新了密码信息</returns>
		// Token: 0x0600176A RID: 5994 RVA: 0x000777D5 File Offset: 0x000759D5
		public OperateResult ChangePassword(string password)
		{
			return this.OperateStatusFromServer(new string[]
			{
				"CONFIG",
				"SET",
				"requirepass",
				password
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ReadServerTime" />
		// Token: 0x0600176B RID: 5995 RVA: 0x00077800 File Offset: 0x00075A00
		[DebuggerStepThrough]
		public Task<OperateResult<DateTime>> ReadServerTimeAsync()
		{
			RedisClient.<ReadServerTimeAsync>d__225 <ReadServerTimeAsync>d__ = new RedisClient.<ReadServerTimeAsync>d__225();
			<ReadServerTimeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<DateTime>>.Create();
			<ReadServerTimeAsync>d__.<>4__this = this;
			<ReadServerTimeAsync>d__.<>1__state = -1;
			<ReadServerTimeAsync>d__.<>t__builder.Start<RedisClient.<ReadServerTimeAsync>d__225>(ref <ReadServerTimeAsync>d__);
			return <ReadServerTimeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Ping" />
		// Token: 0x0600176C RID: 5996 RVA: 0x00077844 File Offset: 0x00075A44
		[DebuggerStepThrough]
		public Task<OperateResult> PingAsync()
		{
			RedisClient.<PingAsync>d__226 <PingAsync>d__ = new RedisClient.<PingAsync>d__226();
			<PingAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<PingAsync>d__.<>4__this = this;
			<PingAsync>d__.<>1__state = -1;
			<PingAsync>d__.<>t__builder.Start<RedisClient.<PingAsync>d__226>(ref <PingAsync>d__);
			return <PingAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.DBSize" />
		// Token: 0x0600176D RID: 5997 RVA: 0x00077888 File Offset: 0x00075A88
		[DebuggerStepThrough]
		public Task<OperateResult<long>> DBSizeAsync()
		{
			RedisClient.<DBSizeAsync>d__227 <DBSizeAsync>d__ = new RedisClient.<DBSizeAsync>d__227();
			<DBSizeAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<DBSizeAsync>d__.<>4__this = this;
			<DBSizeAsync>d__.<>1__state = -1;
			<DBSizeAsync>d__.<>t__builder.Start<RedisClient.<DBSizeAsync>d__227>(ref <DBSizeAsync>d__);
			return <DBSizeAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.FlushDB" />
		// Token: 0x0600176E RID: 5998 RVA: 0x000778CC File Offset: 0x00075ACC
		[DebuggerStepThrough]
		public Task<OperateResult> FlushDBAsync()
		{
			RedisClient.<FlushDBAsync>d__228 <FlushDBAsync>d__ = new RedisClient.<FlushDBAsync>d__228();
			<FlushDBAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<FlushDBAsync>d__.<>4__this = this;
			<FlushDBAsync>d__.<>1__state = -1;
			<FlushDBAsync>d__.<>t__builder.Start<RedisClient.<FlushDBAsync>d__228>(ref <FlushDBAsync>d__);
			return <FlushDBAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.ChangePassword(System.String)" />
		// Token: 0x0600176F RID: 5999 RVA: 0x00077910 File Offset: 0x00075B10
		[DebuggerStepThrough]
		public Task<OperateResult> ChangePasswordAsync(string password)
		{
			RedisClient.<ChangePasswordAsync>d__229 <ChangePasswordAsync>d__ = new RedisClient.<ChangePasswordAsync>d__229();
			<ChangePasswordAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<ChangePasswordAsync>d__.<>4__this = this;
			<ChangePasswordAsync>d__.password = password;
			<ChangePasswordAsync>d__.<>1__state = -1;
			<ChangePasswordAsync>d__.<>t__builder.Start<RedisClient.<ChangePasswordAsync>d__229>(ref <ChangePasswordAsync>d__);
			return <ChangePasswordAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 将信息 message 发送到指定的频道 channel，返回接收到信息 message 的订阅者数量。
		/// </summary>
		/// <param name="channel">频道，和关键字不是一回事</param>
		/// <param name="message">消息</param>
		/// <returns>接收到信息 message 的订阅者数量。</returns>
		// Token: 0x06001770 RID: 6000 RVA: 0x0007795B File Offset: 0x00075B5B
		public OperateResult<int> Publish(string channel, string message)
		{
			return this.OperateNumberFromServer(new string[]
			{
				"PUBLISH",
				channel,
				message
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.Publish(System.String,System.String)" />
		// Token: 0x06001771 RID: 6001 RVA: 0x0007797C File Offset: 0x00075B7C
		[DebuggerStepThrough]
		public Task<OperateResult<int>> PublishAsync(string channel, string message)
		{
			RedisClient.<PublishAsync>d__231 <PublishAsync>d__ = new RedisClient.<PublishAsync>d__231();
			<PublishAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<PublishAsync>d__.<>4__this = this;
			<PublishAsync>d__.channel = channel;
			<PublishAsync>d__.message = message;
			<PublishAsync>d__.<>1__state = -1;
			<PublishAsync>d__.<>t__builder.Start<RedisClient.<PublishAsync>d__231>(ref <PublishAsync>d__);
			return <PublishAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。默认使用 0 号数据库。
		/// </summary>
		/// <param name="db">索引值</param>
		/// <returns>是否切换成功</returns>
		// Token: 0x06001772 RID: 6002 RVA: 0x000779D0 File Offset: 0x00075BD0
		public OperateResult SelectDB(int db)
		{
			OperateResult operateResult = this.OperateStatusFromServer(new string[]
			{
				"SELECT",
				db.ToString()
			});
			bool isSuccess = operateResult.IsSuccess;
			if (isSuccess)
			{
				this.dbBlock = db;
			}
			return operateResult;
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SelectDB(System.Int32)" />
		// Token: 0x06001773 RID: 6003 RVA: 0x00077A14 File Offset: 0x00075C14
		[DebuggerStepThrough]
		public Task<OperateResult> SelectDBAsync(int db)
		{
			RedisClient.<SelectDBAsync>d__233 <SelectDBAsync>d__ = new RedisClient.<SelectDBAsync>d__233();
			<SelectDBAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<SelectDBAsync>d__.<>4__this = this;
			<SelectDBAsync>d__.db = db;
			<SelectDBAsync>d__.<>1__state = -1;
			<SelectDBAsync>d__.<>t__builder.Start<RedisClient.<SelectDBAsync>d__233>(ref <SelectDBAsync>d__);
			return <SelectDBAsync>d__.<>t__builder.Task;
		}

		/// <summary>
		/// 当接收到Redis订阅的信息的时候触发
		/// </summary>
		// Token: 0x14000036 RID: 54
		// (add) Token: 0x06001774 RID: 6004 RVA: 0x00077A60 File Offset: 0x00075C60
		// (remove) Token: 0x06001775 RID: 6005 RVA: 0x00077A98 File Offset: 0x00075C98
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event RedisClient.RedisMessageReceiveDelegate OnRedisMessageReceived;

		// Token: 0x06001776 RID: 6006 RVA: 0x00077AD0 File Offset: 0x00075CD0
		private RedisSubscribe RedisSubscribeInitialize()
		{
			RedisSubscribe redisSubscribe = new RedisSubscribe(this.IpAddress, this.Port);
			redisSubscribe.Password = this.password;
			redisSubscribe.OnRedisMessageReceived += delegate(string topic, string message)
			{
				RedisClient.RedisMessageReceiveDelegate onRedisMessageReceived = this.OnRedisMessageReceived;
				if (onRedisMessageReceived != null)
				{
					onRedisMessageReceived(topic, message);
				}
			};
			return redisSubscribe;
		}

		/// <summary>
		/// 从Redis服务器订阅一个或多个主题信息<br />
		/// Subscribe to one or more topics from the redis server
		/// </summary>
		/// <param name="topic">主题信息</param>
		/// <returns>订阅结果</returns>
		// Token: 0x06001777 RID: 6007 RVA: 0x00077B15 File Offset: 0x00075D15
		public OperateResult SubscribeMessage(string topic)
		{
			return this.SubscribeMessage(new string[]
			{
				topic
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.SubscribeMessage(System.String)" />
		// Token: 0x06001778 RID: 6008 RVA: 0x00077B27 File Offset: 0x00075D27
		public OperateResult SubscribeMessage(string[] topics)
		{
			return this.redisSubscribe.Value.SubscribeMessage(topics);
		}

		/// <summary>
		/// 取消订阅一个或多个主题信息，取消之后，当前的订阅数据就不在接收到。<br />
		/// Unsubscribe from multiple topic information. After cancellation, the current subscription data will not be received.
		/// </summary>
		/// <param name="topic">主题信息</param>
		/// <returns>取消订阅结果</returns>
		// Token: 0x06001779 RID: 6009 RVA: 0x00077B3A File Offset: 0x00075D3A
		public OperateResult UnSubscribeMessage(string topic)
		{
			return this.UnSubscribeMessage(new string[]
			{
				topic
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Enthernet.Redis.RedisClient.UnSubscribeMessage(System.String)" />
		// Token: 0x0600177A RID: 6010 RVA: 0x00077B4C File Offset: 0x00075D4C
		public OperateResult UnSubscribeMessage(string[] topics)
		{
			return this.redisSubscribe.Value.UnSubscribeMessage(topics);
		}

		/// <inheritdoc />
		// Token: 0x0600177B RID: 6011 RVA: 0x00077B5F File Offset: 0x00075D5F
		public override string ToString()
		{
			return string.Format("RedisClient[{0}:{1}]", this.IpAddress, this.Port);
		}

		// Token: 0x0400052E RID: 1326
		private string password = string.Empty;

		// Token: 0x0400052F RID: 1327
		private int dbBlock = 0;

		// Token: 0x04000530 RID: 1328
		private Lazy<RedisSubscribe> redisSubscribe;

		/// <summary>
		/// 当接收到Redis订阅的信息的时候触发<br />
		/// Triggered when receiving Redis subscription information
		/// </summary>
		/// <param name="topic">主题信息</param>
		/// <param name="message">数据信息</param>
		// Token: 0x020006C5 RID: 1733
		// (Invoke) Token: 0x06002FC6 RID: 12230
		public delegate void RedisMessageReceiveDelegate(string topic, string message);
	}
}
